#ifndef _ITAPS_iMesh
#define _ITAPS_iMesh

#include "iBase.h"
#include "iMesh_protos.h"

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *VersionNumbers
                                                                               * \brief Compile time
                                                                               *version number
                                                                               *digits
                                                                               *
                                                                               * iMesh maintains a
                                                                               *major, minor and
                                                                               *patch digit in its
                                                                               *version number.
                                                                               * Technically
                                                                               *speaking, there is
                                                                               *not much practical
                                                                               *value in patch digit
                                                                               * for an interface
                                                                               *specification. A
                                                                               *patch release is
                                                                               *typically only used
                                                                               * for bug fix
                                                                               *releases. Although
                                                                               *it is rare,
                                                                               *sometimes a bug fix
                                                                               * necessitates an API
                                                                               *change. So, we
                                                                               *define a patch digit
                                                                               *for iMesh.
                                                                               ******************************************************************************/
#define IMESH_VERSION_MAJOR ITAPS_VERSION_MAJOR
#define IMESH_VERSION_MINOR ITAPS_VERSION_MINOR
#define IMESH_VERSION_PATCH ITAPS_VERSION_PATCH

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *VersionNumbers
                                                                               * \brief Maintain
                                                                               *backward
                                                                               *compatibility with
                                                                               *old version symbol
                                                                               *names
                                                                               ******************************************************************************/
#define IMESH_MAJOR_VERSION IMESH_VERSION_MAJOR
#define IMESH_MINOR_VERSION IMESH_VERSION_MINOR
#define IMESH_PATCH_VERSION IMESH_VERSION_PATCH

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *VersionNumbers
                                                                               * \brief Version
                                                                               *Comparison
                                                                               *
                                                                               * Evaluates to true
                                                                               *at CPP time if the
                                                                               *version of iMesh
                                                                               *currently being
                                                                               * compiled is greater
                                                                               *than or equal to the
                                                                               *version specified.
                                                                               ******************************************************************************/
#define IMESH_VERSION_GE( Maj, Min, Pat ) ITAPS_VERSION_GE( Maj, Min, Pat )

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *VersionNumbers
                                                                               * \brief Compose
                                                                               *string represention
                                                                               *of the iMesh version
                                                                               *number
                                                                               ******************************************************************************/
#define IMESH_VERSION_STRING ITAPS_VERSION_STRING_( iMesh )

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *VersionNumbers
                                                                               * \brief Compose a
                                                                               *symbol name derived
                                                                               *from the current
                                                                               *iMesh version
                                                                               *number.
                                                                               ******************************************************************************/
#define IMESH_VERSION_TAG ITAPS_VERSION_TAG_( iMesh )

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *VersionNumbers
                                                                               * \brief Define
                                                                               *iMesh_newMesh symbol
                                                                               *such that it depends
                                                                               *on version number.
                                                                               *
                                                                               * Note: We ran into
                                                                               *problems with this
                                                                               *as it influences or
                                                                               *is influenced by
                                                                               * fortran name
                                                                               *mangling and so
                                                                               *breaks fortran
                                                                               *compilation. So,
                                                                               *this is currently
                                                                               *disabled.
                                                                               ******************************************************************************/
#define IMESH_NEW_MESH_NAME__( A, B, C ) A##_##B##_##C
#define IMESH_NEW_MESH_NAME_( A, B, C )  IMESH_NEW_MESH_NAME__( A, B, C )
#define IMESH_NEW_MESH_NAME( A )         IMESH_NEW_MESH_NAME_( A, IMESH_VERSION_MAJOR, IMESH_VERSION_MINOR )
/*
#undef  iMesh_newMesh
#define iMesh_newMesh IMESH_NEW_MESH_NAME(iMesh_newMesh)
*/

#ifdef __cplusplus
extern "C" {
#endif

/***************************************************************************/ /**
                                                                               * \ingroup Datatypes
                                                                               * \brief iMesh
                                                                               *instance
                                                                               ******************************************************************************/
typedef struct iMesh_Instance_Private* iMesh_Instance;

/***************************************************************************/ /**
                                                                               * \ingroup Datatypes
                                                                               * \brief Entity
                                                                               *Topology
                                                                               ******************************************************************************/
enum iMesh_EntityTopology
{
    iMesh_EntityTopology_MIN = 0,
    /**< MIN symbol used to facilitate iteration over topologies */
    iMesh_POINT = iMesh_EntityTopology_MIN,
    /**< a 0D entity (e.g. a vertex) */
    iMesh_LINE_SEGMENT,
    /**< a 1D entity (e.g. an edge) */
    iMesh_POLYGON,
    /**< a general 2D entity */
    iMesh_TRIANGLE,
    /**< a specific 2D entity bounded by 3 edge entities */
    iMesh_QUADRILATERAL,
    /**< a specific 2D entity bounded by 4 edge entities */
    iMesh_POLYHEDRON,
    /**< a general 3D entity */
    iMesh_TETRAHEDRON,
    /**< a specific 3D entity bounded by 4 triangle entities */
    iMesh_HEXAHEDRON,
    /**< a specific 3D entity bounded by 6 quadrilateral entities */
    iMesh_PRISM,
    /**< a specific 3D entity bounded by a combination of 3 quadrilateral
        entities and 2 triangle entities */
    iMesh_PYRAMID,
    /**< a specific 3D entity bounded by a combination of 1 quadrilateral
         entity and 4 triangle entities */
    iMesh_SEPTAHEDRON,
    /**< a hexahedral entity with one collapsed edge */
    iMesh_ALL_TOPOLOGIES,
    /**< used only in queries to request information about all topologies */
    iMesh_EntityTopology_MAX = iMesh_ALL_TOPOLOGIES
    /**< MAX symbol used to facilitate iteration over topologies */
};

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *ErrorHandling \brief
                                                                               *Get the error type
                                                                               *returned from the
                                                                               *last iMesh function
                                                                               ******************************************************************************/
void iMesh_getErrorType( iMesh_Instance instance,
                         /**< [in] iMesh instance handle */
                         int* error_type
                         /**< [out] Error type returned from last iMesh function
                              (see iBase_ErrorType) */

);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *ErrorHandling \brief
                                                                               *Get a description of
                                                                               *the error returned
                                                                               *from the last iMesh
                                                                               *function
                                                                               ******************************************************************************/
void iMesh_getDescription( iMesh_Instance instance,
                           /**< [in] iMesh instance handle */
                           char* descr,
                           /**< [in,out] Pointer to a character string to be filled with a
                              description of the error from the last iMesh function */
                           int descr_len
                           /**< [in] Length of the character string pointed to by descr
                                (\ref strlen) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Initialization
                                                                               * \brief  Construct a
                                                                               *new iMesh instance
                                                                               *
                                                                               ******************************************************************************/

void iMesh_newMesh( const char* options,
                    /**< [in] Pointer to implementation-specific options string
                         (\ref options) */
                    iMesh_Instance* instance,
                    /**< [in] iMesh instance handle */
                    int* err,
                    /**< [out] Returned Error status (see iBase_ErrorType) */
                    int options_len
                    /**< [in] Length of the character string pointed to by options
                         (\ref strlen) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Initialization
                                                                               * \brief  Destroy an
                                                                               *iMesh instance
                                                                               *
                                                                               ******************************************************************************/

void iMesh_dtor( iMesh_Instance instance,
                 /**< [in] iMesh instance handle */
                 int* err
                 /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Initialization
                                                                               * \brief  Load a mesh
                                                                               *from a file
                                                                               *
                                                                               * Load a mesh from a
                                                                               *file.  If entity set
                                                                               *is specified, loaded
                                                                               *mesh is added to
                                                                               *that set; specify
                                                                               *root set if that is
                                                                               *not desired.
                                                                               ******************************************************************************/

void iMesh_load( iMesh_Instance instance,
                 /**< [in] iMesh instance handle */
                 const iBase_EntitySetHandle entity_set_handle,
                 /**< [in] Set to which loaded mesh will be added, otherwise root */
                 const char* name,
                 /**< [in] File name from which mesh is to be loaded */
                 const char* options,
                 /**< [in] Pointer to implementation-specific options string
                      (\ref options) */
                 int* err,
                 /**< [out] Returned Error status (see iBase_ErrorType) */
                 int name_len,
                 /**< [in] Length of the file name character string
                      (\ref strlen) */
                 int options_len
                 /**< [in] Length of the options character string
                      (\ref strlen) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Initialization
                                                                               * \brief  Save a mesh
                                                                               *to a file
                                                                               *
                                                                               * Save a mesh to a
                                                                               *file.  If entity set
                                                                               *is specified, save
                                                                               *only the mesh
                                                                               *contained in that
                                                                               *set.
                                                                               ******************************************************************************/

void iMesh_save( iMesh_Instance instance,
                 /**< [in] iMesh instance handle */
                 const iBase_EntitySetHandle entity_set_handle,
                 /**< [in] Entity set being saved */
                 const char* name,
                 /**< [in] File name to which mesh is to be saved */
                 const char* options,
                 /**< [in] Pointer to implementation-specific options string
                      (\ref options) */
                 int* err,
                 /**< [out] Returned Error status (see iBase_ErrorType) */
                 const int name_len,
                 /**< [in] Length of the file name character string
                      (\ref strlen) */
                 int options_len
                 /**< [in] Length of the options character string
                      (\ref strlen) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Initialization
                                                                               * \brief  Get handle
                                                                               *of the root set for
                                                                               *this instance
                                                                               *
                                                                               * Get handle of the
                                                                               *root set for this
                                                                               *instance.  All mesh
                                                                               *entities in this
                                                                               *instance can be
                                                                               *accessed from this
                                                                               *set.
                                                                               ******************************************************************************/

void iMesh_getRootSet( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       iBase_EntitySetHandle* root_set,
                       /**< [out] Pointer to set handle returned from function */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Initialization
                                                                               * \brief  Get the
                                                                               *geometric dimension
                                                                               *of mesh represented
                                                                               *in this instance
                                                                               *
                                                                               ******************************************************************************/

void iMesh_getGeometricDimension( iMesh_Instance instance,
                                  /**< [in] iMesh instance handle */
                                  int* geom_dim,
                                  /**< [out] Pointer to dimension returned from this function */
                                  int* err
                                  /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Initialization
                                                                               * \brief  Set
                                                                               *geometric dimension
                                                                               *of vertex
                                                                               *coordinates
                                                                               *
                                                                               * Set the geometric
                                                                               *dimension of the
                                                                               *mesh.  Note:  An
                                                                               *application should
                                                                               *not expect this
                                                                               *function to succeed
                                                                               *unless the mesh
                                                                               *instance is empty.
                                                                               *An empty mesh
                                                                               *instance is any mesh
                                                                               *instance in which
                                                                               *there are no vertex
                                                                               *entities.
                                                                               ******************************************************************************/

void iMesh_setGeometricDimension( iMesh_Instance instance,
                                  /**< [in] iMesh instance handle */
                                  int geom_dim,
                                  /**< [in] Requested geometric dimension. */
                                  int* err
                                  /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Initialization
                                                                               * \brief  Get the
                                                                               *default storage
                                                                               *order used by this
                                                                               *implementation
                                                                               *
                                                                               * Get the default
                                                                               *storage order used
                                                                               *by this
                                                                               *implementation.
                                                                               *Value returned is a
                                                                               *member of the
                                                                               *iBase_StorageOrder
                                                                               *enumeration.
                                                                               ******************************************************************************/

void iMesh_getDfltStorage( iMesh_Instance instance,
                           /**< [in] iMesh instance handle */
                           int* order,
                           /**< [out] Pointer to storage order returned from function
                                (\sa iBase_StorageOrder) */
                           int* err
                           /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Adjacencies \brief
                                                                               *Get the adjacency
                                                                               *table for this
                                                                               *implementation
                                                                               *
                                                                               * Get the adjacency
                                                                               *table for this
                                                                               *implementation. This
                                                                               *table is a 4x4 array
                                                                               *whose entries
                                                                               *characterize how the
                                                                               *implementation
                                                                               * behaves when
                                                                               *adjacent and
                                                                               *intermediate
                                                                               *entities are
                                                                               *queried. Entry [i,j]
                                                                               *(i=row, j=col,
                                                                               *0-based indexing)
                                                                               *will have one of the
                                                                               *values in the
                                                                               *iBase_AdjacencyCost
                                                                               *enumeration.
                                                                               *Off-diagonal entres,
                                                                               *i!=j, represents the
                                                                               *relative cost of
                                                                               *retrieving entities
                                                                               *of dimension i
                                                                               *adjacent to entities
                                                                               *of dimension j.
                                                                               * Diagonal entries,
                                                                               *i==j, indicate
                                                                               *whether or not
                                                                               *handles to ALL
                                                                               * entities of that
                                                                               *dimension are
                                                                               *obtainable from
                                                                               *calls that return
                                                                               * entity handles.
                                                                               *This is always true
                                                                               *by definition for
                                                                               *i==j==0 as well as
                                                                               *for i==j==2 in a 2D
                                                                               *mesh and i==j==3 in
                                                                               *a 3D mesh. However,
                                                                               *diagonal entries
                                                                               *[1,1] for a 2D mesh
                                                                               *and both [1,1] and
                                                                               *[2,2] for a 3D mesh
                                                                               *indicate whether or
                                                                               *not handles to ALL
                                                                               * intermediate
                                                                               *dimensioned entities
                                                                               *(ALL edges in a 2D
                                                                               *mesh or ALL edges
                                                                               *and ALL faces in a
                                                                               *3D mesh) are
                                                                               *obtainable from
                                                                               *calls that return
                                                                               *entity handles. A
                                                                               *value of
                                                                               *iBase_AVAILABLE for
                                                                               *a diagonal entry
                                                                               *indicates that
                                                                               *handles are
                                                                               *obtainable for ALL
                                                                               * entities of that
                                                                               *dimension while a
                                                                               *value of
                                                                               *iBase_UNAVAILABLE
                                                                               * indicates that
                                                                               *handles are not
                                                                               *obtainable for ALL
                                                                               *entities of that
                                                                               * dimension.
                                                                               ******************************************************************************/

void iMesh_getAdjTable( iMesh_Instance instance,
                        /**< [in] iMesh instance handle */
                        int** adjacency_table,
                        /**< [out] Pointer to array representing adjacency table
                             \ref trio) */
                        int* adjacency_table_allocated,
                        /**< [in,out] Pointer to allocated size of adjacency_table */
                        int* adjacency_table_size,
                        /**< [out] Pointer to occupied size of adjacency_table */
                        int* err
                        /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Adjacencies \brief
                                                                               *Set the adjacency
                                                                               *table as requested
                                                                               *by the application
                                                                               *
                                                                               * Set the adjacency
                                                                               *table as requested
                                                                               *by the application.
                                                                               * See
                                                                               *iMesh_getAdjTable
                                                                               *for a description of
                                                                               *the meaning of the
                                                                               *entries in this
                                                                               *table. This call to
                                                                               *set the adjacency
                                                                               *table allows an
                                                                               *application to
                                                                               *request how it would
                                                                               *like an
                                                                               *implementation to
                                                                               *behave when adjacent
                                                                               * and/or intermediate
                                                                               *entities are
                                                                               *queried. If the
                                                                               *implementation is
                                                                               *not able to
                                                                               *accommodate the
                                                                               *requested query
                                                                               *behavior associated
                                                                               *with ANY entry in
                                                                               *the table, the call
                                                                               *will fail and return
                                                                               *an error of
                                                                               * iBase_NOT_SUPPORTED.
                                                                               *Otherwise, the
                                                                               *implementation is
                                                                               *able to accommodate
                                                                               * the requested query
                                                                               *behavior associated
                                                                               *with ALL table
                                                                               *entries and the call
                                                                               *will succeed. In
                                                                               *either case,
                                                                               *however, the
                                                                               *implementation will
                                                                               * over-write the
                                                                               *entries in the
                                                                               *adjacency_table
                                                                               *argument with the
                                                                               *same values that
                                                                               *would be obtained in
                                                                               *a succeeding call to
                                                                               *iMesh_getAdjTable.
                                                                               ******************************************************************************/

void iMesh_setAdjTable( iMesh_Instance instance,
                        /**< [in] iMesh instance handle */
                        int* adjacency_table,
                        /**< [in,out] Array representing adjacency table requested by
                             application */
                        int adjacency_table_size,
                        /**< [in] Size of adj table array */
                        int* err
                        /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Get the
                                                                               *number of entities
                                                                               *of specified type in
                                                                               *the instance or set
                                                                               *
                                                                               * Get the number of
                                                                               *entities with the
                                                                               *specified type in
                                                                               *the instance or set.
                                                                               *If entity set handle
                                                                               *is root set, return
                                                                               *information for
                                                                               *instance, otherwise
                                                                               *for set.  Value of
                                                                               *entity type must be
                                                                               *from the
                                                                               * iBase_EntityType
                                                                               *enumeration.  If
                                                                               *iBase_ALL_TYPES is
                                                                               *specified, total
                                                                               *number of entities
                                                                               *(excluding entity
                                                                               *sets) is returned.
                                                                               ******************************************************************************/

void iMesh_getNumOfType( iMesh_Instance instance,
                         /**< [in] iMesh instance handle */
                         const iBase_EntitySetHandle entity_set_handle,
                         /**< [in] Entity set being queried */
                         const int entity_type,
                         /**< [in] Type of entity requested */
                         int* num_type,
                         /**< [out] Pointer to number of entities, returned from function */
                         int* err
                         /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Get the
                                                                               *number of entities
                                                                               *of specified
                                                                               *topology in instance
                                                                               *or set
                                                                               *
                                                                               * Get the number of
                                                                               *entities with the
                                                                               *specified topology
                                                                               *in the instance or
                                                                               *set.  If entity set
                                                                               *handle is root set,
                                                                               *return information
                                                                               *for instance,
                                                                               * otherwise for set.
                                                                               *Value of entity
                                                                               *topology must be
                                                                               *from the
                                                                               * iMesh_EntityTopology
                                                                               *enumeration.  If
                                                                               *iMesh_ALL_TOPOLOGIES
                                                                               *is specified, total
                                                                               *number of entities
                                                                               *(excluding entity
                                                                               *sets) is returned.
                                                                               ******************************************************************************/

void iMesh_getNumOfTopo( iMesh_Instance instance,
                         /**< [in] iMesh instance handle */
                         const iBase_EntitySetHandle entity_set_handle,
                         /**< [in] Entity set being queried */
                         const int entity_topology,
                         /**< [in] Topology of entity requested */
                         int* num_topo,
                         /**< [out] Pointer to number of entities, returned from function */
                         int* err
                         /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *MeshModification
                                                                               * \brief Permit
                                                                               *implementation to
                                                                               *'optimize' the mesh
                                                                               *instance
                                                                               *
                                                                               * Its concievable
                                                                               *that after a series
                                                                               *of operations
                                                                               *modifying the mesh
                                                                               * instance, the
                                                                               *implementation's
                                                                               *internal
                                                                               *representation of
                                                                               *the mesh may include
                                                                               *data and tie up
                                                                               *memory resources
                                                                               *that could be
                                                                               *'optimized' away.
                                                                               * For example, if the
                                                                               *implementation only
                                                                               *marks removed
                                                                               *entities for
                                                                               *deletion but does
                                                                               *not actually free up
                                                                               *memory resources
                                                                               *associated those
                                                                               *entities, a call to
                                                                               *this function gives
                                                                               *the implementation
                                                                               *the 'ok' to go ahead
                                                                               *and free up such
                                                                               *memory.
                                                                               *
                                                                               * Depending on the
                                                                               *implementation as
                                                                               *well as the amount
                                                                               *and kind of changes
                                                                               * to the mesh that
                                                                               *have been made prior
                                                                               *to calling it, this
                                                                               *call may be very
                                                                               *expensive in time
                                                                               *complexity. On the
                                                                               *other hand, it is
                                                                               *also perfectly
                                                                               * acceptable that an
                                                                               *implementation
                                                                               *basically treat this
                                                                               *operation as a
                                                                               *no-op.
                                                                               *
                                                                               * In any event, any
                                                                               *entity, entity set,
                                                                               *iterator or tag
                                                                               *handle obtained
                                                                               *prior to calling
                                                                               *this method will may
                                                                               *be invalidated as a
                                                                               *result of this call.
                                                                               *In that case, the
                                                                               *caller must
                                                                               *re-acquire handles
                                                                               *after making this
                                                                               *call. A return
                                                                               *argument indicates
                                                                               *if handles have been
                                                                               *invalidated.
                                                                               ******************************************************************************/

void iMesh_optimize( iMesh_Instance instance,
                     /**< [in] iMesh instance handle */
                     int* handles_invalidated,
                     /**< [out] Returned flag indicating if any handles the caller held
                          before calling this function have been invalidated as a result of
                          this call. A value of non-zero returned here indicates that any
                          handles the caller had prior to this call must not be trusted and
                          must be re-acquired by caller. */
                     int* err
                     /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Entities
                                                                               * \brief  Get
                                                                               *entities of specific
                                                                               *type and/or topology
                                                                               *in set or instance
                                                                               *
                                                                               * Get entities of
                                                                               *specific type and/or
                                                                               *topology in set or
                                                                               *instance.  All
                                                                               * entities of a given
                                                                               *type or topology are
                                                                               *requested by
                                                                               *specifying
                                                                               * iBase_ALL_TOPOLOGIES
                                                                               *or iBase_ALL_TYPES,
                                                                               *respectively.
                                                                               *Specified type or
                                                                               *topology must be a
                                                                               *value in the
                                                                               *iBase_EntityType or
                                                                               *iBase_EntityTopology
                                                                               * enumeration,
                                                                               *respectively.
                                                                               ******************************************************************************/

void iMesh_getEntities( iMesh_Instance instance,
                        /**< [in] iMesh instance handle */
                        const iBase_EntitySetHandle entity_set_handle,
                        /**< [in] Entity set being queried */
                        const int entity_type,
                        /**< [in] Type of entities being requested */
                        const int entity_topology,
                        /**< [in] Topology of entities being requested */
                        iBase_EntityHandle** entity_handles,
                        /**< [in,out] Pointer to array of entity handles returned \ref trio) */
                        int* entity_handles_allocated,
                        /**< [in,out] Pointer to allocated size of entity_handles array */
                        int* entity_handles_size,
                        /**< [out] Pointer to occupied size of entity_handles array */
                        int* err
                        /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *VertexEntities
                                                                               * \brief  Get
                                                                               *coordinates of
                                                                               *specified vertices
                                                                               *
                                                                               * Get coordinates of
                                                                               *specified vertices.
                                                                               *Coordinates are
                                                                               *returned in the
                                                                               *storage order
                                                                               *indicated by the
                                                                               *storage_order
                                                                               *argument.
                                                                               ******************************************************************************/

void iMesh_getVtxArrCoords( iMesh_Instance instance,
                            /**< [in] iMesh instance handle */
                            const iBase_EntityHandle* vertex_handles,
                            /**< [in] Array of mesh vertex handles whose coordinates are being
                                 requested */
                            const int vertex_handles_size,
                            /**< [in] Number of vertices in vertex_handles array */
                            const int storage_order,
                            /**< [in] Requested storage order of returned coordinates
                                 (see iBase_StorageOrder) */
                            double** coords,
                            /**< [in,out] Pointer to array of coordinates returned from function
                                 \ref trio) */
                            int* coords_allocated,
                            /**< [in,out] Pointer to allocated size of coords array */
                            int* coords_size,
                            /**< [out] Pointer to occupied size of coords array */
                            int* err
                            /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *EntityIterators
                                                                               * \brief  Initialize
                                                                               *an array iterator
                                                                               *over specified
                                                                               *entity type,
                                                                               *topology, and size
                                                                               *
                                                                               * Initialize an array
                                                                               *iterator over
                                                                               *specified entity
                                                                               *type, topology, and
                                                                               * size, for a
                                                                               *specified set or
                                                                               *instance.  Iterator
                                                                               *returned can be used
                                                                               * as input to
                                                                               *functions returning
                                                                               *entities for the
                                                                               *iterator.  If all
                                                                               * entities of a
                                                                               *specified type
                                                                               *and/or topology are
                                                                               *to be iterated,
                                                                               * specify
                                                                               *iBase_ALL_TYPES or
                                                                               *iMesh_ALL_TOPOLOGIES,
                                                                               *respectively.
                                                                               * Specified type or
                                                                               *topology must be a
                                                                               *value in the
                                                                               *iBase_EntityType or
                                                                               * iMesh_EntityTopology
                                                                               *enumerations,
                                                                               *respectively.
                                                                               ******************************************************************************/

void iMesh_initEntArrIter( iMesh_Instance instance,
                           /**< [in] iMesh instance handle */
                           const iBase_EntitySetHandle entity_set_handle,
                           /**< [in] Entity set being iterated */
                           const int requested_entity_type,
                           /**< [in] Type of entity to iterate */
                           const int requested_entity_topology,
                           /**< [in] Topology of entity to iterate */
                           const int requested_array_size,
                           /**< [in] Size of chunks of handles returned for each value of the
                                iterator */
                           const int resilient,
                           /**< [in] If zero, return a non-resilient iterator.
                                     Otherwise, a resilient iterator (\ref resilient) */
                           iBase_EntityArrIterator* entArr_iterator,
                           /**< [out] Pointer to iterator returned from function */
                           int* err
                           /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *EntityIterators
                                                                               * \brief  Get
                                                                               *entities contained
                                                                               *in array iterator
                                                                               *and increment
                                                                               *iterator
                                                                               *
                                                                               * Get the entities
                                                                               *corresponding to an
                                                                               *array iterator (e.g.
                                                                               *dereference the
                                                                               *array iterator), and
                                                                               *increment the
                                                                               *iterator. The
                                                                               *dereferenced
                                                                               * value(s) are
                                                                               *returned in
                                                                               *entity_handles. If
                                                                               *the iterator is at
                                                                               *the end of the
                                                                               *iteration, the
                                                                               *dereferenced
                                                                               *value(s) are
                                                                               *undefined and
                                                                               * has_data will be
                                                                               *returned with a
                                                                               *value of zero.
                                                                               *Otherwise, has_data
                                                                               * will be returned
                                                                               *with a non-zero
                                                                               *value.
                                                                               ******************************************************************************/

void iMesh_getNextEntArrIter( iMesh_Instance instance,
                              /**< [in] iMesh instance handle */
                              iBase_EntityArrIterator entArr_iterator,
                              /**< [in] Iterator being queried */
                              iBase_EntityHandle** entity_handles,
                              /**< [in,out] Pointer to array of entity handles contained in current
                                 value of iterator \ref trio) */
                              int* entity_handles_allocated,
                              /**< [in,out] Pointer to allocated size of entity_handles */
                              int* entity_handles_size,
                              /**< [out] Pointer to occupied size of entity_handles  */
                              int* has_data,
                              /**< [out] Pointer to a flag indicating if the value(s) returned
                                 in entity_handles are valid. A non-zero value indicates the value(s)
                                 are valid. A zero value indicates the value(s) are NOT valid. */
                              int* err
                              /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *EntityIterators
                                                                               * \brief  Reset the
                                                                               *array iterator
                                                                               *
                                                                               ******************************************************************************/

void iMesh_resetEntArrIter( iMesh_Instance instance,
                            /**< [in] iMesh instance handle */
                            iBase_EntityArrIterator entArr_iterator,
                            /**< [in] Iterator to reset */
                            int* err
                            /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *EntityIterators
                                                                               * \brief  Destroy the
                                                                               *specified array
                                                                               *iterator
                                                                               *
                                                                               ******************************************************************************/

void iMesh_endEntArrIter( iMesh_Instance instance,
                          /**< [in] iMesh instance handle */
                          iBase_EntityArrIterator entArr_iterator,
                          /**< [in] Iterator which gets destroyed */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Entities
                                                                               * \brief  Get the
                                                                               *entity topology for
                                                                               *the specified
                                                                               *entities
                                                                               *
                                                                               * Get the entity
                                                                               *topology for the
                                                                               *specified entities.
                                                                               *Topologies returned
                                                                               *are values in the
                                                                               *iMesh_EntityTopology
                                                                               *enumeration.
                                                                               ******************************************************************************/

void iMesh_getEntArrTopo( iMesh_Instance instance,
                          /**< [in] iMesh instance handle */
                          const iBase_EntityHandle* entity_handles,
                          /**< [in] Array of entity handles being queried */
                          const int entity_handles_size,
                          /**< [in] Number of entities in entity_handles array */
                          int** topology,
                          /**< [in,out] Pointer to array of entity topologies returned
                               \ref trio) */
                          int* topology_allocated,
                          /**< [in,out] Pointer to allocated size of topology array */
                          int* topology_size,
                          /**< [out] Pointer to occupied size of topology array */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Entities
                                                                               * \brief  Get the
                                                                               *entity type for the
                                                                               *specified entities
                                                                               *
                                                                               * Get the entity type
                                                                               *for the specified
                                                                               *entities.  Types
                                                                               * returned are values
                                                                               *in the
                                                                               *iBase_EntityType
                                                                               *enumeration.
                                                                               ******************************************************************************/

void iMesh_getEntArrType( iMesh_Instance instance,
                          /**< [in] iMesh instance handle */
                          const iBase_EntityHandle* entity_handles,
                          /**< [in] Array of entity handles being queried */
                          const int entity_handles_size,
                          /**< [in] Number of entities in entity_handles array */
                          int** type,
                          /**< [in,out] Pointer to array of types returned from function
                               \ref trio) */
                          int* type_allocated,
                          /**< [in,out] Pointer to allocated size of type array */
                          int* type_size,
                          /**< [out] Pointer to occupied size of type array */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Adjacencies \brief
                                                                               *Get entities of
                                                                               *specified type
                                                                               *adjacent to entities
                                                                               *
                                                                               * Get entities of
                                                                               *specified type
                                                                               *adjacent to
                                                                               *entities.  Specified
                                                                               *type must be value
                                                                               *in the
                                                                               *iBase_EntityType
                                                                               *enumeration.  \em
                                                                               *offset(i) is index
                                                                               *of first entity in
                                                                               *adjacentEntityHandles
                                                                               *array adjacent to
                                                                               * entity_handles[i].
                                                                               *More precisely, the
                                                                               *entities adjacent to
                                                                               *the ith entity in
                                                                               *entity_handles are
                                                                               *found in
                                                                               *adjacentEntityHandles
                                                                               * running from
                                                                               *offset[i] to
                                                                               *offset[i+1] - 1.
                                                                               *This implies that
                                                                               *the offset_size will
                                                                               *be
                                                                               *entity_handles_size
                                                                               *+ 1.
                                                                               *
                                                                               * Note 1: Because
                                                                               *'adjacent' as
                                                                               *defined by the iMesh
                                                                               *data model refers to
                                                                               *those entities that
                                                                               *bound another, the
                                                                               *entities being
                                                                               *queried here (in
                                                                               *entity_handles arg)
                                                                               *are NEVER ALSO
                                                                               *returned in
                                                                               *         adjacentEntityHandles
                                                                               *even if the
                                                                               *entity_type_requested
                                                                               *         matches the
                                                                               *entity type(s) in
                                                                               *entity_handles.
                                                                               ******************************************************************************/

void iMesh_getEntArrAdj( iMesh_Instance instance,
                         /**< [in] iMesh instance handle */
                         const iBase_EntityHandle* entity_handles,
                         /**< [in] Array of entity handles being queried */
                         const int entity_handles_size,
                         /**< [in] Number of entities in entity_handles array */
                         const int entity_type_requested,
                         /**< [in] Type of adjacent entities requested */
                         iBase_EntityHandle** adjacentEntityHandles,
                         /**< [in,out] Pointer to array of adjacentEntityHandles \ref trio)
                            returned from function. Note that the implicit INTERLEAVED storage
                            order rule applies (see iBase_StorageOrder) */
                         int* adjacentEntityHandles_allocated,
                         /**< [in,out] Pointer to allocated size of adjacentEntityHandles array */
                         int* adj_entity_handles_size,
                         /**< [out] Pointer to occupied size of adjacentEntityHandles array */
                         int** offset,
                         /**< [in,out] Pointer to array of offsets returned from function
                              \ref trio) */
                         int* offset_allocated,
                         /**< [in,out] Pointer to allocated size of offset array */
                         int* offset_size,
                         /**< [out] Pointer to occupied size of offset array */
                         int* err
                         /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Adjacencies \brief
                                                                               *Get "2nd order"
                                                                               *adjacencies to an
                                                                               *array of entities
                                                                               *
                                                                               * Get "2nd order"
                                                                               *adjacencies to an
                                                                               *array of entities,
                                                                               *that is, from each
                                                                               * entity, through
                                                                               *other entities of a
                                                                               *specified "bridge"
                                                                               *dimension, to other
                                                                               * entities of another
                                                                               *specified "to"
                                                                               *dimension. Note 1:
                                                                               *If the "bridge"
                                                                               *dimension is the
                                                                               *same as the "to"
                                                                               *dimension, the
                                                                               *output will be empty
                                                                               *(and an error code
                                                                               *of
                                                                               *    iBase_INVALID_ARGUMENT
                                                                               *returned).  If the
                                                                               *type of a particular
                                                                               *    entity matches
                                                                               *the "bridge"
                                                                               *dimension, there
                                                                               *will be no entities
                                                                               *    returned for
                                                                               *that input entity.
                                                                               *This is consistent
                                                                               *with the definition
                                                                               *of adjacencies and
                                                                               *the behavior of
                                                                               *iMesh first
                                                                               *    adjacency calls.
                                                                               * Note 2:  An entity
                                                                               *will never be
                                                                               *returned as a second
                                                                               *adjacency of itself,
                                                                               *on the grounds that
                                                                               *this is the most
                                                                               *likely expectation
                                                                               *of applications, and
                                                                               *that it is easier
                                                                               *for an application
                                                                               *to add the original
                                                                               *entity to the
                                                                               *returned data than
                                                                               *to find and remove
                                                                               *it. Note 3: The
                                                                               *entities adjacent to
                                                                               *the ith entity in
                                                                               *entity_handles are
                                                                               *    found in
                                                                               *adj_entity_handles
                                                                               *running from
                                                                               *offset[i] to
                                                                               *    offset[i+1] - 1.
                                                                               *This implies that
                                                                               *the offset_size will
                                                                               *be
                                                                               *    entity_handles_size
                                                                               *+ 1.
                                                                               ******************************************************************************/

void iMesh_getEntArr2ndAdj( iMesh_Instance instance,
                            /**< [in] iMesh instance handle */
                            iBase_EntityHandle const* entity_handles,
                            /**< [in] Entities from which adjacencies are requested */
                            int entity_handles_size,
                            /**< [in] Number of entities whose adjacencies are requested */
                            int bridge_entity_type,
                            /**< [in]  Type of bridge entity for 2nd order adjacencies */
                            int requested_entity_type,
                            /**< [in] Type of adjacent entities returned */
                            iBase_EntityHandle** adj_entity_handles,
                            /**< [in,out] Adjacent entities. Note that the implicit INTERLEAVED
                                 storage order rule applies (see iBase_StorageOrder)
                                 \ref trio) */
                            int* adj_entity_handles_allocated,
                            /**< [in,out] Allocated size of returned array */
                            int* adj_entity_handles_size,
                            /**< [out] Occupied size of returned array */
                            int** offset,
                            /**< [in,out] Offset[i] is offset into adj_entity_handles of 2nd order
                               adjacencies of ith entity in entity_handles \ref trio) */
                            int* offset_allocated,
                            /**< [in,out] Allocated size of offset array */
                            int* offset_size,
                            /**< [out] Occupied size of offset array */
                            int* err
                            /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Adjacencies \brief
                                                                               *Get indexed
                                                                               *representation of
                                                                               *mesh or subset of
                                                                               *mesh
                                                                               *
                                                                               * Given an entity set
                                                                               *and optionally a
                                                                               *type or topology,
                                                                               *return:
                                                                               * - The entities in
                                                                               *the set of the
                                                                               *specified type or
                                                                               *topology
                                                                               * - The entities
                                                                               *adjacent to those
                                                                               *entities with a
                                                                               *specified type, as a
                                                                               *list of unique
                                                                               *handles.
                                                                               * - For each entity
                                                                               *in the first list,
                                                                               *the adjacent
                                                                               *entities, specified
                                                                               *as indices into the
                                                                               *second list.
                                                                               *
                                                                               * Note 1: Because
                                                                               *'adjacent' as
                                                                               *defined by the iMesh
                                                                               *data model refers to
                                                                               *those entities that
                                                                               *bound another, the
                                                                               *entities being
                                                                               *queried here (in
                                                                               *entity_set_handle
                                                                               *arg) are NEVER ALSO
                                                                               *returned in
                                                                               *         adj_entity_handles
                                                                               *even if the
                                                                               *entity_type_requested
                                                                               *         matches the
                                                                               *entity type(s) in
                                                                               *entity_set_handle.
                                                                               * Note 2: The
                                                                               *entities adjacent to
                                                                               *the ith entity in
                                                                               *entity_handles are
                                                                               *         found in
                                                                               *adj_entity_handles
                                                                               *running from
                                                                               *offset[i] to
                                                                               *         offset[i+1]
                                                                               *- 1.  This implies
                                                                               *that the offset_size
                                                                               *will be
                                                                               *entity_handles_size
                                                                               *+ 1. Note 3: This
                                                                               *function will fail
                                                                               *and return an error
                                                                               *if the caller passes
                                                                               *         a
                                                                               *combination of
                                                                               *entity_type and
                                                                               *entity_topology that
                                                                               *are not consistent.
                                                                               ******************************************************************************/

void iMesh_getAdjEntIndices( iMesh_Instance instance,
                             /**< [in] iMesh instance handle */
                             iBase_EntitySetHandle entity_set_handle,
                             /**< [in] The set of entities from which to query */
                             int entity_type_requester,
                             /**< [in] If not iBase_ALL_TYPES, act only on the subset of entities
                                contained in entity_set_handle of the specified type. */
                             int entity_topology_requester,
                             /**< [in] If not iMesh_ALL_TOPOLOGIES, act only on the subset of
                                entities contained in entity_set_handle of specified topology. */
                             int entity_type_requested,
                             /**< [in] The type of the adjacent entities to return */
                             iBase_EntityHandle** entity_handles,
                             /**< [in,out] The handles of the (non-struct) subset of the entities
                                  contained in entity_set_handle indicated by the optional type and
                                  topology filtering arguments. \ref trio) */
                             int* entity_handles_allocated,
                             /**< [in,out] Allocated size of entity_handles array */
                             int* entity_handles_size,
                             /**< [out] Occupied size of entity_handles array */
                             iBase_EntityHandle** adj_entity_handles,
                             /**< [in,out] The union of the unique entities of type
                                requested_entity_type adjacent to each entity in entity_handles.
                                Note that the implicit INTERLEAVED storage order rule
                                applies (see iBase_StorageOrder) \ref trio) */
                             int* adj_entity_handles_allocated,
                             /**< [in,out] Allocated size of adj_entity_handles array */
                             int* adj_entity_handles_size,
                             /**< [out] Occupied size of adj_entity_handles array */
                             int** adj_entity_indices,
                             /**< [in,out] For each entity in entity_handles, the adjacent
                                entities of type entity_type_requested, specified as indices into
                                adj_entity_handles.  The values are concatenated into a single
                                array in the order of the entity handles in entity_handles.
                                \ref trio) */
                             int* adj_entity_indices_allocated,
                             /**< [in,out] Allocated size of adj_entity_indices array */
                             int* adj_entity_indices_size,
                             /**< [out] Occupied size of adj_entity_indices array */
                             int** offset,
                             /**< [in,out] For each entity in the corresponding position in
                                entity_handles, the position in adj_entity_indices at which
                                values for that entity are stored \ref trio) */
                             int* offset_allocated,
                             /**< [in,out] Allocated size of offset array */
                             int* offset_size,
                             /**< [out] Occipied size of offset array */
                             int* err
                             /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Create an
                                                                               *entity set
                                                                               *
                                                                               * Create an entity
                                                                               *set, either ordered
                                                                               *(isList=1) or
                                                                               *unordered
                                                                               *(isList=0).
                                                                               * Unordered entity
                                                                               *sets can contain a
                                                                               *given entity or set
                                                                               *only once.
                                                                               *
                                                                               * An entity set in
                                                                               *iMesh supports
                                                                               *managing its
                                                                               *contained members in
                                                                               *one of two modes.
                                                                               *When an entitiy set
                                                                               *is first created,
                                                                               *the caller is
                                                                               *required to indicate
                                                                               *which mode of
                                                                               *membership the set
                                                                               *will support. The
                                                                               *two modes that are
                                                                               *supported are a)
                                                                               *order-preserving
                                                                               *(isList=1) or b)
                                                                               *duplicate-preventing
                                                                               *(isList=0).
                                                                               *
                                                                               * For
                                                                               *order-preserving
                                                                               *membership, the
                                                                               *implementation will
                                                                               *permit duplicate
                                                                               * entities. However,
                                                                               *the implementation
                                                                               *will guarantee that
                                                                               *the order in which
                                                                               * entities are added
                                                                               *to the set will be
                                                                               *the same as the
                                                                               *order in which they
                                                                               *are queried by the
                                                                               *various methods that
                                                                               *return the entities
                                                                               *of a set. This order
                                                                               * preserving
                                                                               *guarantee holds
                                                                               *across removals.
                                                                               *However, it does not
                                                                               *hold across removals
                                                                               *followed by
                                                                               *re-additions of the
                                                                               *previously removed
                                                                               *entities. This kind
                                                                               *of an entity set
                                                                               *behaves like an STL
                                                                               *vector or STL list
                                                                               *and is created by
                                                                               *setting isList=1
                                                                               *when creating an
                                                                               *entity set.
                                                                               *
                                                                               * For
                                                                               *duplicate-preventing
                                                                               *membership, the
                                                                               *implementation will
                                                                               *guarantee that
                                                                               * duplicate entities
                                                                               *are prevented. Any
                                                                               *attempts to add
                                                                               *duplicate entities
                                                                               *to such a set will
                                                                               *be detected,
                                                                               *prevented and
                                                                               *silently ignored by
                                                                               *the implementation.
                                                                               *This kind of entity
                                                                               *set behaves like an
                                                                               *STL set and is
                                                                               *created by setting
                                                                               *isList=0 when
                                                                               *creating an entity
                                                                               *set.
                                                                               *
                                                                               * Finally, all of the
                                                                               *above comments apply
                                                                               *only to entity
                                                                               *members of an entity
                                                                               * set and do not
                                                                               *apply to the entity
                                                                               *set members.
                                                                               *Order-preserving and
                                                                               * duplicate
                                                                               *preventing behavior
                                                                               *for entity set
                                                                               *members is
                                                                               *unspecified. Each
                                                                               * implementation may
                                                                               *behave differently
                                                                               *for entity set
                                                                               *members. This design
                                                                               *was chosen because
                                                                               *we could not
                                                                               *identify any use
                                                                               *cases where
                                                                               * order-preserving
                                                                               *behavior for set
                                                                               *members was
                                                                               *necessary. However,
                                                                               *if users encounter
                                                                               *situations where
                                                                               *such behavior is
                                                                               *desirable or
                                                                               *necessary, then the
                                                                               *ITAPS development
                                                                               *team can certainly
                                                                               *consider adjusting
                                                                               *the interface
                                                                               * specification to
                                                                               *support it.
                                                                               ******************************************************************************/

void iMesh_createEntSet( iMesh_Instance instance,
                         /**< [in] iMesh instance handle */
                         const int isList,
                         /**< [in] If non-zero, an ordered list is created, otherwise an
                            unordered set is created. */
                         iBase_EntitySetHandle* entity_set_created,
                         /**< [out] Entity set created by function */
                         int* err
                         /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Destroy an
                                                                               *entity set
                                                                               *
                                                                               ******************************************************************************/

void iMesh_destroyEntSet( iMesh_Instance instance,
                          /**< [in] iMesh instance handle */
                          iBase_EntitySetHandle entity_set,
                          /**< [in] Entity set to be destroyed */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Return
                                                                               *whether a specified
                                                                               *set is ordered or
                                                                               *unordered
                                                                               *
                                                                               * Return whether a
                                                                               *specified set is
                                                                               *ordered (*is_list=1)
                                                                               *or unordered
                                                                               *(*is_list=0)
                                                                               ******************************************************************************/

void iMesh_isList( iMesh_Instance instance,
                   /**< [in] iMesh instance handle */
                   const iBase_EntitySetHandle entity_set,
                   /**< [in] Entity set being queried */
                   int* is_list,
                   /**< [out] Pointer to flag returned from function */
                   int* err
                   /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Get the
                                                                               *number of entity
                                                                               *sets contained in a
                                                                               *set or interface
                                                                               *
                                                                               * Get the number of
                                                                               *entity sets
                                                                               *contained in a set
                                                                               *or interface.
                                                                               ******************************************************************************/

void iMesh_getNumEntSets( iMesh_Instance instance,
                          /**< [in] iMesh instance handle */
                          const iBase_EntitySetHandle entity_set_handle,
                          /**< [in] Entity set being queried */
                          const int num_hops,
                          /**< [in] Maximum hops from entity_set_handle to contained set, not
                               inclusive of the contained set.  \ref numhops) */
                          int* num_sets,
                          /**< [out] Pointer to the number of sets returned from function */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Get the
                                                                               *entity sets
                                                                               *contained in a set
                                                                               *or interface
                                                                               *
                                                                               * Get the entity sets
                                                                               *contained in a set
                                                                               *or interface.
                                                                               ******************************************************************************/

void iMesh_getEntSets( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       const iBase_EntitySetHandle entity_set_handle,
                       /**< [in] Entity set being queried */
                       const int num_hops,
                       /**< [in] Maximum hops from entity_set_handle to contained set, not
                          inclusive of the contained set \ref numhops) */
                       iBase_EntitySetHandle** contained_set_handles,
                       /**< [in,out] Pointer to array of set handles returned \ref trio) */
                       int* contained_set_handles_allocated,
                       /**< [in,out] Pointer to allocated length of */
                       int* contained_set_handles_size,
                       /**< [out] Pointer to occupied length of */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Add an
                                                                               *entity to a set
                                                                               *
                                                                               ******************************************************************************/

void iMesh_addEntToSet( iMesh_Instance instance,
                        /**< [in] iMesh instance handle */
                        iBase_EntityHandle entity_handle,
                        /**< [in] The entity being added */
                        iBase_EntitySetHandle entity_set,
                        /**< [in] Pointer to the set being added to */
                        int* err
                        /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Remove an
                                                                               *entity from a set
                                                                               *
                                                                               ******************************************************************************/

void iMesh_rmvEntFromSet( iMesh_Instance instance,
                          /**< [in] iMesh instance handle */
                          iBase_EntityHandle entity_handle,
                          /**< [in] The entity being removed */
                          iBase_EntitySetHandle entity_set,
                          /**< [in] Pointer to the set being removed from */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Add an
                                                                               *array of entities to
                                                                               *a set
                                                                               *
                                                                               ******************************************************************************/

void iMesh_addEntArrToSet( iMesh_Instance instance,
                           /**< [in] iMesh instance handle */
                           const iBase_EntityHandle* entity_handles,
                           /**< [in] Array of entities being added */
                           int entity_handles_size,
                           /**< [in] Number of entities in entity_handles array */
                           iBase_EntitySetHandle entity_set,
                           /**< [in] Pointer to the set being added to */
                           int* err
                           /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Remove an
                                                                               *array of entities
                                                                               *from a set
                                                                               *
                                                                               ******************************************************************************/

void iMesh_rmvEntArrFromSet( iMesh_Instance instance,
                             /**< [in] iMesh instance handle */
                             const iBase_EntityHandle* entity_handles,
                             /**< [in] Array of entities being remove */
                             int entity_handles_size,
                             /**< [in] Number of entities in entity_handles array */
                             iBase_EntitySetHandle entity_set,
                             /**< [in] Pointer to the set being removed from */
                             int* err
                             /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Add an
                                                                               *entity set to a set
                                                                               *
                                                                               * Add an entity set
                                                                               *to a set (\ref
                                                                               *cycles)
                                                                               ******************************************************************************/

void iMesh_addEntSet( iMesh_Instance instance,
                      /**< [in] iMesh instance handle */
                      iBase_EntitySetHandle entity_set_to_add,
                      /**< [in] The entity set being added */
                      iBase_EntitySetHandle entity_set_handle,
                      /**< [in] Pointer to the set being added to */
                      int* err
                      /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Remove an
                                                                               *entity set from a
                                                                               *set
                                                                               *
                                                                               * Remove an entity
                                                                               *set from a set
                                                                               ******************************************************************************/

void iMesh_rmvEntSet( iMesh_Instance instance,
                      /**< [in] iMesh instance handle */
                      iBase_EntitySetHandle entity_set_to_remove,
                      /**< [in] The entity set being removed */
                      iBase_EntitySetHandle entity_set_handle,
                      /**< [in] Pointer to the set being removed from */
                      int* err
                      /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Return
                                                                               *whether an entity is
                                                                               *contained in another
                                                                               *set
                                                                               *
                                                                               * Return whether an
                                                                               *entity is contained
                                                                               *(*is_contained=1) or
                                                                               *not contained
                                                                               *(*is_contained=0) in
                                                                               *another set
                                                                               ******************************************************************************/

void iMesh_isEntContained( iMesh_Instance instance,
                           /**< [in] iMesh instance handle */
                           iBase_EntitySetHandle containing_entity_set,
                           /**< [in] Entity set being queried */
                           iBase_EntityHandle contained_entity,
                           /**< [in] Entity potentially contained in containing_entity_set */
                           int* is_contained,
                           /**< [out] Pointer to flag returned from function */
                           int* err
                           /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Return
                                                                               *whether entities are
                                                                               *contained in a set
                                                                               *
                                                                               ******************************************************************************/

void iMesh_isEntArrContained( iMesh_Instance instance,
                              /**< [in] iMesh instance handle */
                              iBase_EntitySetHandle containing_entity_set,
                              /**< [in] Entity set being queried */
                              const iBase_EntityHandle* entity_handles,
                              /**< [in] List of entities for which to check containment. */
                              int num_entity_handles,
                              /**< [in] Size of entity_handles array of entities to be checked. */
                              int** is_contained,
                              /**< [in,out] One value for each input entity, 1 if contained in set,
                                   zero otherwise.  \ref trio) */
                              int* is_contained_allocated,
                              /**< [in,out] Allocated size of is_contained array */
                              int* is_contained_size,
                              /**< [out] Occupied size of is_contained array */
                              int* err
                              /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup EntitySets
                                                                               * \brief  Return
                                                                               *whether an entity
                                                                               *set is contained in
                                                                               *another set
                                                                               *
                                                                               * Return whether a
                                                                               *set is contained
                                                                               *(*is_contained=1) or
                                                                               *not contained
                                                                               * (*is_contained=0)
                                                                               *in another set
                                                                               ******************************************************************************/

void iMesh_isEntSetContained( iMesh_Instance instance,
                              /**< [in] iMesh instance handle */
                              const iBase_EntitySetHandle containing_entity_set,
                              /**< [in] Entity set being queried */
                              const iBase_EntitySetHandle contained_entity_set,
                              /**< [in] Entity set potentially contained in containing_entity_set */
                              int* is_contained,
                              /**< [out] Pointer to flag returned from function */
                              int* err
                              /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *ParentChildLinks
                                                                               * \brief  Add
                                                                               *parent/child links
                                                                               *between two sets
                                                                               *
                                                                               * Add parent/child
                                                                               *links between two
                                                                               *sets.  Makes parent
                                                                               *point to child and
                                                                               *child point to
                                                                               *parent. (\ref
                                                                               *cycles)
                                                                               ******************************************************************************/

void iMesh_addPrntChld( iMesh_Instance instance,
                        /**< [in] iMesh instance handle */
                        iBase_EntitySetHandle parent_entity_set,
                        /**< [in] Pointer to parent set */
                        iBase_EntitySetHandle child_entity_set,
                        /**< [in] Pointer to child set */
                        int* err
                        /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *ParentChildLinks
                                                                               * \brief  Remove
                                                                               *parent/child links
                                                                               *between two sets
                                                                               *
                                                                               * Remove parent/child
                                                                               *links between two
                                                                               *sets.
                                                                               ******************************************************************************/

void iMesh_rmvPrntChld( iMesh_Instance instance,
                        /**< [in] iMesh instance handle */
                        iBase_EntitySetHandle parent_entity_set,
                        /**< [in] Pointer to parent set */
                        iBase_EntitySetHandle child_entity_set,
                        /**< [in] Pointer to child set */
                        int* err
                        /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *ParentChildLinks
                                                                               * \brief  Return
                                                                               *whether two sets are
                                                                               *related by
                                                                               *parent/child links
                                                                               *
                                                                               * Return whether two
                                                                               *sets are related
                                                                               *(*is_child=1) or not
                                                                               *(*is_child=0) by
                                                                               *parent/child links
                                                                               ******************************************************************************/

void iMesh_isChildOf( iMesh_Instance instance,
                      /**< [in] iMesh instance handle */
                      const iBase_EntitySetHandle parent_entity_set,
                      /**< [in] Pointer to parent set */
                      const iBase_EntitySetHandle child_entity_set,
                      /**< [in] Pointer to child set */
                      int* is_child,
                      /**< [out] Pointer to flag returned from function */
                      int* err
                      /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *ParentChildLinks
                                                                               * \brief  Get the
                                                                               *number of child sets
                                                                               *linked from a
                                                                               *specified set
                                                                               *
                                                                               * Get the number of
                                                                               *child sets linked
                                                                               *from a specified
                                                                               *set.
                                                                               ******************************************************************************/

void iMesh_getNumChld( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       const iBase_EntitySetHandle entity_set,
                       /**< [in] Entity set being queried */
                       const int num_hops,
                       /**< [in] Maximum hops from entity_set_handle to child set, not
                          inclusive of the child set.  \ref numhops) */
                       int* num_child,
                       /**< [out] Pointer to number of children returned from function */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *ParentChildLinks
                                                                               * \brief  Get the
                                                                               *number of parent
                                                                               *sets linked from a
                                                                               *specified set
                                                                               *
                                                                               * Get the number of
                                                                               *parent sets linked
                                                                               *from a specified
                                                                               *set.
                                                                               ******************************************************************************/

void iMesh_getNumPrnt( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       const iBase_EntitySetHandle entity_set,
                       /**< [in] Entity set being queried */
                       const int num_hops,
                       /**< [in] Maximum hops from entity_set_handle to parent set, not
                          inclusive of the parent set.  \ref numhops) */
                       int* num_parent,
                       /**< [out] Pointer to number of parents returned from function */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *ParentChildLinks
                                                                               * \brief  Get the
                                                                               *child sets linked
                                                                               *from a specified set
                                                                               *
                                                                               * Get the child sets
                                                                               *linked from a
                                                                               *specified set.
                                                                               ******************************************************************************/

void iMesh_getChldn( iMesh_Instance instance,
                     /**< [in] iMesh instance handle */
                     const iBase_EntitySetHandle from_entity_set,
                     /**< [in] Entity set being queried */
                     const int num_hops,
                     /**< [in] Maximum hops from entity_set_handle to child set,
                        \ref numhops) */
                     iBase_EntitySetHandle** entity_set_handles,
                     /**< [in,out] Pointer to array of child sets \ref trio) */
                     int* entity_set_handles_allocated,
                     /**< [in,out] Pointer to allocated size of  */
                     int* entity_set_handles_size,
                     /**< [out] Pointer to occupied size of  */
                     int* err
                     /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *ParentChildLinks
                                                                               * \brief  Get the
                                                                               *parent sets linked
                                                                               *from a specified set
                                                                               *
                                                                               * Get the parent sets
                                                                               *linked from a
                                                                               *specified set.
                                                                               ******************************************************************************/

void iMesh_getPrnts( iMesh_Instance instance,
                     /**< [in] iMesh instance handle */
                     const iBase_EntitySetHandle from_entity_set,
                     /**< [in] Entity set being queried */
                     const int num_hops,
                     /**< [in] Maximum hops from entity_set_handle to parent set,
                        \ref numhops) */
                     iBase_EntitySetHandle** entity_set_handles,
                     /**< [in,out] Pointer to array of parent sets \ref trio) */
                     int* entity_set_handles_allocated,
                     /**< [in,out] Pointer to allocated size of  */
                     int* entity_set_handles_size,
                     /**< [out] Pointer to occupied size of  */
                     int* err
                     /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *VertexEntities
                                                                               * \brief  Set
                                                                               *coordinates for an
                                                                               *array of vertices
                                                                               *
                                                                               * Set coordinates for
                                                                               *an array of
                                                                               *vertices.  Specified
                                                                               *storage order must
                                                                               *be either
                                                                               *iBase_INTERLEAVED or
                                                                               *iBase_BLOCKED, and
                                                                               * indicates order of
                                                                               *x, y, and z
                                                                               *coordinates in
                                                                               *coordinate array.
                                                                               ******************************************************************************/

void iMesh_setVtxArrCoords( iMesh_Instance instance,
                            /**< [in] iMesh instance handle */
                            const iBase_EntityHandle* vertex_handles,
                            /**< [in] Array of vertex handles */
                            const int vertex_handles_size,
                            /**< [in] Number of vertex handles in array */
                            const int storage_order,
                            /**< [in] Storage order of coordinates in coordinate array */
                            const double* new_coords,
                            /**< [in] Coordinate array */
                            const int new_coords_size,
                            /**< [in] Size of coordinate array; should be  */
                            int* err
                            /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *VertexEntities
                                                                               * \brief  Create an
                                                                               *array of new
                                                                               *vertices at
                                                                               *specified
                                                                               *coordinates
                                                                               *
                                                                               * Create an array of
                                                                               *new vertices at
                                                                               *specified
                                                                               *coordinates.  Value
                                                                               *of storage_order
                                                                               *must be either
                                                                               *iBase_INTERLEAVED or
                                                                               *iBase_BLOCKED.
                                                                               ******************************************************************************/

void iMesh_createVtxArr( iMesh_Instance instance,
                         /**< [in] iMesh instance handle */
                         const int num_verts,
                         /**< [in] Number of new vertices to be created */
                         const int storage_order,
                         /**< [in] Storage order of coordinates in new_coords array
                              (see iBase_StorageOrder) */
                         const double* new_coords,
                         /**< [in] Array of coordinates of new vertices. Should be G*num_verts
                            in length where G is geometric dimension of the mesh. */
                         const int new_coords_size,
                         /**< [in] Number of coordinates in new_coords array, should */
                         iBase_EntityHandle** new_vertex_handles,
                         /**< [in,out] Pointer to array of new vertex handles \ref trio) */
                         int* new_vertex_handles_allocated,
                         /**< [in,out] Pointer to allocated size of  */
                         int* new_vertex_handles_size,
                         /**< [out] Pointer to occupied size of  */
                         int* err
                         /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Entities
                                                                               * \brief  Create an
                                                                               *array of new
                                                                               *entities with
                                                                               *specified
                                                                               *lower-order topology
                                                                               *
                                                                               * Create an array of
                                                                               *new entities with
                                                                               *specified
                                                                               *lower-order
                                                                               *topology. Specified
                                                                               *new_entity_topology
                                                                               *must be value in
                                                                               *iMesh_EntityTopology
                                                                               * enumeration. Values
                                                                               *return in status
                                                                               *array must be values
                                                                               *in the
                                                                               * iBase_CreationStatus
                                                                               *enumeration.
                                                                               ******************************************************************************/

void iMesh_createEntArr( iMesh_Instance instance,
                         /**< [in] iMesh instance handle */
                         const int new_entity_topology,
                         /**< [in] Topology of created entity */
                         const iBase_EntityHandle* lower_order_entity_handles,
                         /**< [in] Array of lower order entity handles to be used to construct
                              new entities */
                         const int lower_order_entity_handles_size,
                         /**< [in] Number of entities in lower_order_entity_handles array */
                         iBase_EntityHandle** new_entity_handles,
                         /**< [in,out] Pointer to array of new_entity_handles
                              \ref trio) */
                         int* new_entity_handles_allocated,
                         /**< [in,out] Pointer to allocated size of  */
                         int* new_entity_handles_size,
                         /**< [out] Pointer to occupied size of  */
                         int** status,
                         /**< [in,out] Pointer to array of creation status returned from
                            \ref trio) (see iBase_CreationStatus) */
                         int* status_allocated,
                         /**< [in,out] Pointer to allocated size of status array */
                         int* status_size,
                         /**< [out] Pointer to occupied size of status array */
                         int* err
                         /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Entities
                                                                               * \brief  Delete
                                                                               *specified entities
                                                                               *
                                                                               * Delete specified
                                                                               *entities
                                                                               ******************************************************************************/

void iMesh_deleteEntArr( iMesh_Instance instance,
                         /**< [in] iMesh instance handle */
                         const iBase_EntityHandle* entity_handles,
                         /**< [in] Array of entity handles to be deleted */
                         const int entity_handles_size,
                         /**< [in] Number of entities in array to be deleted */
                         int* err
                         /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Tags
                                                                               * \brief  Create a
                                                                               *tag with specified
                                                                               *name, size, and type
                                                                               *
                                                                               * Create a tag with
                                                                               *specified name,
                                                                               *size, and type.  Tag
                                                                               *size is in units of
                                                                               *size of tag_type
                                                                               *data types.  Value
                                                                               *input for tag type
                                                                               *must be value in
                                                                               *iBase_TagType
                                                                               *enumeration.
                                                                               ******************************************************************************/

void iMesh_createTag( iMesh_Instance instance,
                      /**< [in] iMesh instance handle */
                      const char* tag_name,
                      /**< [in] Character string indicating tag name */
                      const int tag_size,
                      /**< [in] Size of each tag value, in units of number of
                           tag_type datums. */
                      const int tag_type,
                      /**< [in] Data type for data stored in this tag */
                      iBase_TagHandle* tag_handle,
                      /**< [out] Pointer to tag handle returned from function */
                      int* err,
                      /**< [out] Returned Error status (see iBase_ErrorType) */
                      const int tag_name_len
                      /**< [in] Length of tag name string (\ref strlen) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Tags
                                                                               * \brief  Destroy a
                                                                               *tag
                                                                               *
                                                                               * Destroy a tag.  If
                                                                               *forced is non-zero
                                                                               *and entities still
                                                                               *have values set for
                                                                               *this tag, tag is
                                                                               *deleted anyway and
                                                                               *those values
                                                                               *disappear, otherwise
                                                                               *tag is not deleted.
                                                                               ******************************************************************************/

void iMesh_destroyTag( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       iBase_TagHandle tag_handle,
                       /**< [in] Handle of tag to be deleted */
                       const int forced,
                       /**< [in] If non-zero, delete the tag even if entities have values set
                          for the tag. */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Tags
                                                                               * \brief  Get the
                                                                               *name for a given tag
                                                                               *handle
                                                                               *
                                                                               * Get the name for a
                                                                               *given tag handle
                                                                               ******************************************************************************/

void iMesh_getTagName( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       const iBase_TagHandle tag_handle,
                       /**< [in] Tag handle being queried */
                       char* name,
                       /**< [in,out] Pointer to character string to store name returned from */
                       int* err,
                       /**< [out] Returned Error status (see iBase_ErrorType) */
                       int name_len
                       /**< [in] Length of character string input to function
                            (\ref strlen) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Tags
                                                                               * \brief  Get size of
                                                                               *a tag in units of
                                                                               *numbers of tag data
                                                                               *type
                                                                               *
                                                                               * Get size of a tag
                                                                               *in units of numbers
                                                                               *of tag data type
                                                                               ******************************************************************************/

void iMesh_getTagSizeValues( iMesh_Instance instance,
                             /**< [in] iMesh instance handle */
                             const iBase_TagHandle tag_handle,
                             /**< [in] Handle of tag being queried */
                             int* tag_size,
                             /**< [out] Pointer to tag size returned from function */
                             int* err
                             /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Tags
                                                                               * \brief  Get size of
                                                                               *a tag in units of
                                                                               *bytes
                                                                               *
                                                                               * Get size of a tag
                                                                               *in units of bytes
                                                                               ******************************************************************************/

void iMesh_getTagSizeBytes( iMesh_Instance instance,
                            /**< [in] iMesh instance handle */
                            const iBase_TagHandle tag_handle,
                            /**< [in] Handle of tag being queried */
                            int* tag_size,
                            /**< [out] Pointer to tag size returned from function */
                            int* err
                            /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Tags
                                                                               * \brief  Get a the
                                                                               *handle of an
                                                                               *existing tag with
                                                                               *the specified name
                                                                               *
                                                                               * Get a the handle of
                                                                               *an existing tag with
                                                                               *the specified name
                                                                               ******************************************************************************/

void iMesh_getTagHandle( iMesh_Instance instance,
                         /**< [in] iMesh instance handle */
                         const char* tag_name,
                         /**< [in] Name of tag being queried */
                         iBase_TagHandle* tag_handle,
                         /**< [out] Pointer to tag handle returned from function */
                         int* err,
                         /**< [out] Returned Error status (see iBase_ErrorType) */
                         int tag_name_len
                         /**< [in] Length of tag name string (\ref strlen) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Tags
                                                                               * \brief  Get the
                                                                               *data type of the
                                                                               *specified tag handle
                                                                               *
                                                                               * Get the data type
                                                                               *of the specified tag
                                                                               *handle.  Tag type is
                                                                               *a value in the
                                                                               *iBase_TagType
                                                                               *enumeration.
                                                                               ******************************************************************************/

void iMesh_getTagType( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       const iBase_TagHandle tag_handle,
                       /**< [in] Handle for the tag being queried */
                       int* tag_type,
                       /**< [out] Pointer to tag type returned from function */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnSets
                                                                               * \brief  Set a tag
                                                                               *value of arbitrary
                                                                               *type on an entity
                                                                               *set
                                                                               *
                                                                               * Set a tag value of
                                                                               *arbitrary type on an
                                                                               *entity set. The tag
                                                                               *data is passed as
                                                                               *void*.
                                                                               *tag_value_size
                                                                               *specifies the size
                                                                               *of the memory
                                                                               * pointed to by
                                                                               *tag_value in terms
                                                                               *of bytes.
                                                                               *Applications are
                                                                               *free to use this
                                                                               *function to set data
                                                                               *of any type, not
                                                                               *just iBase_BYTES.
                                                                               * However, in all
                                                                               *cases, the size
                                                                               *specified by
                                                                               *tag_value_size is
                                                                               * always in terms of
                                                                               *bytes.
                                                                               ******************************************************************************/

void iMesh_setEntSetData( iMesh_Instance instance,
                          /**< [in] iMesh instance handle */
                          iBase_EntitySetHandle entity_set_handle,
                          /**< [in] Entity set on which tag is being set */
                          const iBase_TagHandle tag_handle,
                          /**< [in] Tag being set on an entity set */
                          const void* tag_value,
                          /**< [in] Pointer to tag data being set on entity set */
                          const int tag_value_size,
                          /**< [in] Size in bytes of tag data */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnSets
                                                                               * \brief  Set a tag
                                                                               *value of integer
                                                                               *type on an entity
                                                                               *set
                                                                               *
                                                                               * Set a tag value of
                                                                               *integer type on an
                                                                               *entity set.
                                                                               ******************************************************************************/

void iMesh_setEntSetIntData( iMesh_Instance instance,
                             /**< [in] iMesh instance handle */
                             iBase_EntitySetHandle entity_set,
                             /**< [in] Entity set on which tag is being set */
                             const iBase_TagHandle tag_handle,
                             /**< [in] Tag being set on an entity set */
                             const int tag_value,
                             /**< [in] Tag value being set on entity set */
                             int* err
                             /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnSets
                                                                               * \brief  Set a tag
                                                                               *value of double type
                                                                               *on an entity set
                                                                               *
                                                                               * Set a tag value of
                                                                               *double type on an
                                                                               *entity set.
                                                                               ******************************************************************************/

void iMesh_setEntSetDblData( iMesh_Instance instance,
                             /**< [in] iMesh instance handle */
                             iBase_EntitySetHandle entity_set,
                             /**< [in] Entity set on which tag is being set */
                             const iBase_TagHandle tag_handle,
                             /**< [in] Tag being set on an entity set */
                             const double tag_value,
                             /**< [in] Tag value being set on entity set */
                             int* err
                             /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnSets
                                                                               * \brief  Set a tag
                                                                               *value of entity
                                                                               *handle type on an
                                                                               *entity set
                                                                               *
                                                                               * Set a tag value of
                                                                               *entity handle type
                                                                               *on an entity set.
                                                                               ******************************************************************************/

void iMesh_setEntSetEHData( iMesh_Instance instance,
                            /**< [in] iMesh instance handle */
                            iBase_EntitySetHandle entity_set,
                            /**< [in] Entity set on which tag is being set */
                            const iBase_TagHandle tag_handle,
                            /**< [in] Tag being set on an entity set */
                            const iBase_EntityHandle tag_value,
                            /**< [in] Tag value being set on entity set */
                            int* err
                            /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnSets
                                                                               * \brief  Set a tag
                                                                               *value of entity set
                                                                               *handle type on an
                                                                               *
                                                                               *         entity set
                                                                               * Set a tag value of
                                                                               *entity set handle
                                                                               *type on an entity
                                                                               *set.
                                                                               ******************************************************************************/

void iMesh_setEntSetESHData( iMesh_Instance instance,
                             /**< [in] iMesh instance handle */
                             iBase_EntitySetHandle entity_set,
                             /**< [in] Entity set on which tag is being set */
                             const iBase_TagHandle tag_handle,
                             /**< [in] Tag being set on an entity set */
                             const iBase_EntitySetHandle tag_value,
                             /**< [in] Tag value being set on entity set */
                             int* err
                             /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnSets
                                                                               * \brief  Get the
                                                                               *value of a tag of
                                                                               *arbitrary type on an
                                                                               *entity set
                                                                               *
                                                                               * Get the value of a
                                                                               *tag of arbitrary
                                                                               *type on an entity
                                                                               *set.  Tag data is
                                                                               *returned back as
                                                                               *void*.
                                                                               *tag_value_size
                                                                               *specifies the size
                                                                               *of the memory
                                                                               *pointed to by
                                                                               *tag_value in terms
                                                                               *of bytes.
                                                                               *Applications may use
                                                                               *this function to get
                                                                               *data of any type,
                                                                               *not just
                                                                               *iBase_BYTES. However
                                                                               *because this
                                                                               *function supports
                                                                               *data of arbitrary
                                                                               *type, in all cases
                                                                               *the size specified
                                                                               *by tag_value_size is
                                                                               *always in terms of
                                                                               *bytes.
                                                                               ******************************************************************************/

void iMesh_getEntSetData( iMesh_Instance instance,
                          /**< [in] iMesh instance handle */
                          const iBase_EntitySetHandle entity_set_handle,
                          /**< [in] Entity set on which tag is being set */
                          const iBase_TagHandle tag_handle,
                          /**< [in] Tag being set on an entity set */
                          void* tag_value,
                          /**< [in,out] Pointer to tag data array being queried
                               \ref trio) */
                          int* tag_value_allocated,
                          /**< [in,out] Pointer allocated size, in bytes, of tag_value array. */
                          int* tag_value_size,
                          /**< [out] Pointer to occupied size, in bytes, of tag_value array. */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnSets
                                                                               * \brief  Get the
                                                                               *value of a tag of
                                                                               *integer type on an
                                                                               *entity set
                                                                               *
                                                                               * Get the value of a
                                                                               *tag of integer type
                                                                               *on an entity set.
                                                                               ******************************************************************************/

void iMesh_getEntSetIntData( iMesh_Instance instance,
                             /**< [in] iMesh instance handle */
                             const iBase_EntitySetHandle entity_set,
                             /**< [in] Entity set on which tag is being set */
                             const iBase_TagHandle tag_handle,
                             /**< [in] Tag being set on an entity set */
                             int* out_data,
                             /**< [out] Pointer to tag value returned from function */
                             int* err
                             /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnSets
                                                                               * \brief  Get the
                                                                               *value of a tag of
                                                                               *double type on an
                                                                               *entity set
                                                                               *
                                                                               * Get the value of a
                                                                               *tag of double type
                                                                               *on an entity set.
                                                                               ******************************************************************************/

void iMesh_getEntSetDblData( iMesh_Instance instance,
                             /**< [in] iMesh instance handle */
                             const iBase_EntitySetHandle entity_set,
                             /**< [in] Entity set on which tag is being set */
                             const iBase_TagHandle tag_handle,
                             /**< [in] Tag being set on an entity set */
                             double* out_data,
                             /**< [out] Pointer to tag value returned from function */
                             int* err
                             /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnSets
                                                                               * \brief  Get the
                                                                               *value of a tag of
                                                                               *entity handle type
                                                                               *on an entity set
                                                                               *
                                                                               * Get the value of a
                                                                               *tag of entity handle
                                                                               *type on an entity
                                                                               *set.
                                                                               ******************************************************************************/

void iMesh_getEntSetEHData( iMesh_Instance instance,
                            /**< [in] iMesh instance handle */
                            const iBase_EntitySetHandle entity_set,
                            /**< [in] Entity set on which tag is being set */
                            const iBase_TagHandle tag_handle,
                            /**< [in] Tag being set on an entity set */
                            iBase_EntityHandle* out_data,
                            /**< [out] Pointer to tag value returned from function */
                            int* err
                            /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnSets
                                                                               * \brief  Get the
                                                                               *value of a tag of
                                                                               *entity set handle
                                                                               *type on an
                                                                               *
                                                                               *         entity set
                                                                               * Get the value of a
                                                                               *tag of entity set
                                                                               *handle type on an
                                                                               *entity set.
                                                                               ******************************************************************************/

void iMesh_getEntSetESHData( iMesh_Instance instance,
                             /**< [in] iMesh instance handle */
                             const iBase_EntitySetHandle entity_set,
                             /**< [in] Entity set on which tag is being set */
                             const iBase_TagHandle tag_handle,
                             /**< [in] Tag being set on an entity set */
                             iBase_EntitySetHandle* out_data,
                             /**< [out] Pointer to tag value returned from function */
                             int* err
                             /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Tags
                                                                               * \brief  Get all the
                                                                               *tags associated with
                                                                               *a specified entity
                                                                               *set
                                                                               *
                                                                               * Get all the tags
                                                                               *associated with a
                                                                               *specified entity set
                                                                               ******************************************************************************/

void iMesh_getAllEntSetTags( iMesh_Instance instance,
                             /**< [in] iMesh instance handle */
                             const iBase_EntitySetHandle entity_set_handle,
                             /**< [in] Entity being queried */
                             iBase_TagHandle** tag_handles,
                             /**< [in,out] Pointer to array of tag_handles returned from
                                  \ref trio) */
                             int* tag_handles_allocated,
                             /**< [in,out] Pointer to allocated size of tag_handles  */
                             int* tag_handles_size,
                             /**< [out] Pointer to occupied size of tag_handles array */
                             int* err
                             /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Tags
                                                                               * \brief  Remove a
                                                                               *tag value from an
                                                                               *entity set
                                                                               *
                                                                               * Remove a tag value
                                                                               *from an entity set
                                                                               ******************************************************************************/

void iMesh_rmvEntSetTag( iMesh_Instance instance,
                         /**< [in] iMesh instance handle */
                         iBase_EntitySetHandle entity_set_handle,
                         /**< [in] Entity set from which tag is being removed */
                         const iBase_TagHandle tag_handle,
                         /**< [in] Tag handle of tag being removed */
                         int* err
                         /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *VertexEntities
                                                                               * \brief  Set
                                                                               *coordinates for a
                                                                               *vertex
                                                                               *
                                                                               * Set coordinates for
                                                                               *a vertex.
                                                                               ******************************************************************************/

void iMesh_setVtxCoord( iMesh_Instance instance,
                        /**< [in] iMesh instance handle */
                        iBase_EntityHandle vertex_handle,
                        /**< [in] vertex handle being set */
                        const double x,
                        /**< [in] x coordinate being set */
                        const double y,
                        /**< [in] y coordinate being set */
                        const double z,
                        /**< [in] z coordinate being set */
                        int* err
                        /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *VertexEntities
                                                                               * \brief  Create a
                                                                               *new vertex at
                                                                               *specified
                                                                               *coordinates
                                                                               *
                                                                               * Create a new vertex
                                                                               *at specified
                                                                               *coordinates.
                                                                               ******************************************************************************/

void iMesh_createVtx( iMesh_Instance instance,
                      /**< [in] iMesh instance handle */
                      const double x,
                      /**< [in] x coordinate of new vertex */
                      const double y,
                      /**< [in] y coordinate of new vertex */
                      const double z,
                      /**< [in] z coordinate of new vertex */
                      iBase_EntityHandle* new_vertex_handle,
                      /**< [out] Pointer to new vertex handles returned from  */
                      int* err
                      /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Entities
                                                                               * \brief  Create a
                                                                               *new entity with
                                                                               *specified
                                                                               *lower-order topology
                                                                               *
                                                                               * Create a new entity
                                                                               *with specified
                                                                               *lower-order
                                                                               *topology. Specified
                                                                               *new_entity_topology
                                                                               *must be value in
                                                                               *iMesh_EntityTopology
                                                                               * enumeration.  Value
                                                                               *returned as status
                                                                               *must be a value in
                                                                               *the
                                                                               * iBase_CreationStatus
                                                                               *enumeration.
                                                                               ******************************************************************************/

void iMesh_createEnt( iMesh_Instance instance,
                      /**< [in] iMesh instance handle */
                      const int new_entity_topology,
                      /**< [in] Topology of created entity */
                      const iBase_EntityHandle* lower_order_entity_handles,
                      /**< [in] Array of lower order entity handles to be used to construct
                         new entity. */
                      const int lower_order_entity_handles_size,
                      /**< [in] Number of entities in lower_order_entity_handles array */
                      iBase_EntityHandle* new_entity_handle,
                      /**< [out] Pointer to new entity handle returned from  */
                      int* status,
                      /**< [out] Pointer to creation status returned from function
                         (see iBase_CreationStatus) */
                      int* err
                      /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Entities
                                                                               * \brief  Delete
                                                                               *specified entity
                                                                               *
                                                                               * Delete specified
                                                                               *entity
                                                                               ******************************************************************************/

void iMesh_deleteEnt( iMesh_Instance instance,
                      /**< [in] iMesh instance handle */
                      iBase_EntityHandle entity_handle,
                      /**< [in] Entity to be deleted */
                      int* err
                      /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  TagsOnArr
                                                                               * \brief  Get tag
                                                                               *values of arbitrary
                                                                               *type for an array of
                                                                               *entities
                                                                               *
                                                                               * Get tag values of
                                                                               *arbitrary type for
                                                                               *an array of
                                                                               *entities.  Tag data
                                                                               * is returned as
                                                                               *void*.
                                                                               *tag_values_size
                                                                               *specifies the size
                                                                               *of the memory
                                                                               *pointed to by
                                                                               *tag_values in terms
                                                                               *of bytes.
                                                                               *Applications may use
                                                                               *this function to get
                                                                               *data of any type,
                                                                               *not just
                                                                               *iBase_BYTES.
                                                                               * However, because
                                                                               *this function
                                                                               *supports data of
                                                                               *arbitrary type, in
                                                                               * all cases the size
                                                                               *specified by
                                                                               *tag_values_size
                                                                               *always in terms of
                                                                               * bytes.
                                                                               ******************************************************************************/

void iMesh_getArrData( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       const iBase_EntityHandle* entity_handles,
                       /**< [in] Entity array on which tag is being set */
                       const int entity_handles_size,
                       /**< [in] Number of entities in array */
                       const iBase_TagHandle tag_handle,
                       /**< [in] Tag being set on an entity */
                       void* tag_values,
                       /**< [in,out] Pointer to tag data array being returned. Note that the
                          implicit INTERLEAVED storage order rule applies
                          (see iBase_StorageOrder) \ref trio) */
                       int* tag_values_allocated,
                       /**< [in,out] Pointer to allocated size of tag data array */
                       int* tag_values_size,
                       /**< [out] Pointer to occupied size in bytes of tag data */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  TagsOnArr
                                                                               * \brief  Get tag
                                                                               *values of integer
                                                                               *type for an array of
                                                                               *entities
                                                                               *
                                                                               * Get tag values of
                                                                               *integer type for an
                                                                               *array of entities.
                                                                               ******************************************************************************/

void iMesh_getIntArrData( iMesh_Instance instance,
                          /**< [in] iMesh instance handle */
                          const iBase_EntityHandle* entity_handles,
                          /**< [in] Entity array on which tag is being set */
                          const int entity_handles_size,
                          /**< [in] Number of entities in array */
                          const iBase_TagHandle tag_handle,
                          /**< [in] Tag being set on an entity */
                          int** tag_values,
                          /**< [in,out] Pointer to tag data array being returned. Note that the
                             implicit INTERLEAVED storage order rule applies
                             (see iBase_StorageOrder) \ref trio) */
                          int* tag_values_allocated,
                          /**< [in,out] Pointer to allocated size of tag data array */
                          int* tag_values_size,
                          /**< [out] Pointer to occupied size of tag data array */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  TagsOnArr
                                                                               * \brief  Get tag
                                                                               *values of double
                                                                               *type for an array of
                                                                               *entities
                                                                               *
                                                                               * Get tag values of
                                                                               *double type for an
                                                                               *array of entities.
                                                                               ******************************************************************************/

void iMesh_getDblArrData( iMesh_Instance instance,
                          /**< [in] iMesh instance handle */
                          const iBase_EntityHandle* entity_handles,
                          /**< [in] Entity array on which tag is being set */
                          const int entity_handles_size,
                          /**< [in] Number of entities in array */
                          const iBase_TagHandle tag_handle,
                          /**< [in] Tag being set on an entity */
                          double** tag_values,
                          /**< [in,out] Pointer to tag data array being returned. Note that the
                             implicit INTERLEAVED storage order rule applies
                             (see iBase_StorageOrder) \ref trio) */
                          int* tag_values_allocated,
                          /**< [in,out] Pointer to allocated size of tag data array */
                          int* tag_values_size,
                          /**< [out] Pointer to occupied size of tag data array */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  TagsOnArr
                                                                               * \brief  Get tag
                                                                               *values of entity
                                                                               *handle type for an
                                                                               *array of entities
                                                                               *
                                                                               * Get tag values of
                                                                               *entity handle type
                                                                               *for an array of
                                                                               *entities.
                                                                               ******************************************************************************/

void iMesh_getEHArrData( iMesh_Instance instance,
                         /**< [in] iMesh instance handle */
                         const iBase_EntityHandle* entity_handles,
                         /**< [in] Entity array on which tag is being set */
                         const int entity_handles_size,
                         /**< [in] Number of entities in array */
                         const iBase_TagHandle tag_handle,
                         /**< [in] Tag being set on an entity */
                         iBase_EntityHandle** tag_value,
                         /**< [in,out] Pointer to tag data array being returned. Note that the
                            implicit INTERLEAVED storage order rule applies
                            (see iBase_StorageOrder) \ref trio) */
                         int* tag_value_allocated,
                         /**< [in,out] Pointer to allocated size of tag data array */
                         int* tag_value_size,
                         /**< [out] Pointer to occupied size of tag data array */
                         int* err
                         /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  TagsOnArr
                                                                               * \brief  Get tag
                                                                               *values of entity set
                                                                               *handle type for an
                                                                               *array of
                                                                               *
                                                                               *         entities
                                                                               * Get tag values of
                                                                               *entity set handle
                                                                               *type for an array of
                                                                               *entities.
                                                                               ******************************************************************************/

void iMesh_getESHArrData( iMesh_Instance instance,
                          /**< [in] iMesh instance handle */
                          const iBase_EntityHandle* entity_handles,
                          /**< [in] Entity array on which tag is being set */
                          const int entity_handles_size,
                          /**< [in] Number of entities in array */
                          const iBase_TagHandle tag_handle,
                          /**< [in] Tag being set on an entity */
                          iBase_EntitySetHandle** tag_value,
                          /**< [in,out] Pointer to tag data array being returned. Note that the
                             implicit INTERLEAVED storage order rule applies
                             (see iBase_StorageOrder) \ref trio) */
                          int* tag_value_allocated,
                          /**< [in,out] Pointer to allocated size of tag data array */
                          int* tag_value_size,
                          /**< [out] Pointer to occupied size of tag data array */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  TagsOnArr
                                                                               * \brief  Set tag
                                                                               *values of arbitrary
                                                                               *type on an array of
                                                                               *entities
                                                                               *
                                                                               * Set tag values of
                                                                               *arbitrary type on an
                                                                               *array of entities.
                                                                               *Tag data is passed
                                                                               *as void*.
                                                                               *tag_values_size
                                                                               *specifies the size
                                                                               *of the memory
                                                                               *pointed to by
                                                                               *tag_values in terms
                                                                               *of bytes.
                                                                               *Applications may use
                                                                               *this function to set
                                                                               *data of any type,
                                                                               *not just
                                                                               *iBase_BYTES.
                                                                               * However, because
                                                                               *this function
                                                                               *supports data of
                                                                               *arbitrary type, in
                                                                               *all cases the size
                                                                               *specified by
                                                                               *tag_values_size is
                                                                               *always in terms of
                                                                               * bytes.
                                                                               ******************************************************************************/

void iMesh_setArrData( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       const iBase_EntityHandle* entity_handles,
                       /**< [in] Entity array on which tag is being set */
                       const int entity_handles_size,
                       /**< [in] Number of entities in array */
                       const iBase_TagHandle tag_handle,
                       /**< [in] Tag being set on an entity */
                       const void* tag_values,
                       /**< [in] Pointer to tag data being set on entity. Note that the
                          implicit INTERLEAVED storage order rule applies
                          (see iBase_StorageOrder) */
                       const int tag_values_size,
                       /**< [in] Size in bytes of tag data */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  TagsOnArr
                                                                               * \brief  Set tag
                                                                               *values of integer
                                                                               *type on an array of
                                                                               *entities
                                                                               *
                                                                               * Set tag values of
                                                                               *integer type on an
                                                                               *array of entities.
                                                                               ******************************************************************************/

void iMesh_setIntArrData( iMesh_Instance instance,
                          /**< [in] iMesh instance handle */
                          const iBase_EntityHandle* entity_handles,
                          /**< [in] Entity array on which tag is being set */
                          const int entity_handles_size,
                          /**< [in] Number of entities in array */
                          const iBase_TagHandle tag_handle,
                          /**< [in] Tag being set on an entity */
                          const int* tag_values,
                          /**< [in] Pointer to tag data being set on entities. Note that the
                               implicit INTERLEAVED storage order rule applies
                               (see iBase_StorageOrder) */
                          const int tag_values_size,
                          /**< [in] Size in total number of integers of tag data */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  TagsOnArr
                                                                               * \brief  Set tag
                                                                               *values of double
                                                                               *type on an array of
                                                                               *entities
                                                                               *
                                                                               * Set tag values of
                                                                               *double type on an
                                                                               *array of entities.
                                                                               ******************************************************************************/

void iMesh_setDblArrData( iMesh_Instance instance,
                          /**< [in] iMesh instance handle */
                          const iBase_EntityHandle* entity_handles,
                          /**< [in] Entity array on which tag is being set */
                          const int entity_handles_size,
                          /**< [in] Number of entities in array */
                          const iBase_TagHandle tag_handle,
                          /**< [in] Tag being set on an entity */
                          const double* tag_values,
                          /**< [in] Pointer to tag data being set on entities. Note that the
                               implicit INTERLEAVED storage order rule applies
                               (see iBase_StorageOrder) */
                          const int tag_values_size,
                          /**< [in] Size in total number of doubles of tag data */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  TagsOnArr
                                                                               * \brief  Set tag
                                                                               *values of entity
                                                                               *handle type on an
                                                                               *array of entities
                                                                               *
                                                                               * Set tag values of
                                                                               *entity handle type
                                                                               *on an array of
                                                                               *entities.
                                                                               ******************************************************************************/

void iMesh_setEHArrData( iMesh_Instance instance,
                         /**< [in] iMesh instance handle */
                         const iBase_EntityHandle* entity_handles,
                         /**< [in] Entity array on which tag is being set */
                         const int entity_handles_size,
                         /**< [in] Number of entities in array */
                         const iBase_TagHandle tag_handle,
                         /**< [in] Tag being set on an entity */
                         const iBase_EntityHandle* tag_values,
                         /**< [in] Pointer to tag data being set on entities. Note that the
                            implicit INTERLEAVED storage order rule applies
                            (see iBase_StorageOrder) */
                         const int tag_values_size,
                         /**< [in] Size in total number of entity handles of tag  */
                         int* err
                         /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  TagsOnArr
                                                                               * \brief  Set tag
                                                                               *values of entity set
                                                                               *handle type on an
                                                                               *array of
                                                                               *
                                                                               *         entities
                                                                               * Set tag values of
                                                                               *entity set handle
                                                                               *type on an array of
                                                                               *entities.
                                                                               ******************************************************************************/

void iMesh_setESHArrData( iMesh_Instance instance,
                          /**< [in] iMesh instance handle */
                          const iBase_EntityHandle* entity_handles,
                          /**< [in] Entity array on which tag is being set */
                          const int entity_handles_size,
                          /**< [in] Number of entities in array */
                          const iBase_TagHandle tag_handle,
                          /**< [in] Tag being set on an entity */
                          const iBase_EntitySetHandle* tag_values,
                          /**< [in] Pointer to tag data being set on entities. Note that the
                             implicit INTERLEAVED storage order rule applies
                             (see iBase_StorageOrder) */
                          const int tag_values_size,
                          /**< [in] Size in total number of entity handles of tag  */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Tags
                                                                               * \brief  Remove a
                                                                               *tag value from an
                                                                               *array of entities
                                                                               *
                                                                               * Remove a tag value
                                                                               *from an array of
                                                                               *entities
                                                                               ******************************************************************************/

void iMesh_rmvArrTag( iMesh_Instance instance,
                      /**< [in] iMesh instance handle */
                      const iBase_EntityHandle* entity_handles,
                      /**< [in] Entity from which tag is being removed */
                      const int entity_handles_size,
                      /**< [in] Number of entities in entity array */
                      const iBase_TagHandle tag_handle,
                      /**< [in] Tag handle of tag being removed */
                      int* err
                      /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnEnts
                                                                               * \brief  Get the
                                                                               *value of a tag of
                                                                               *arbitrary type on an
                                                                               *entity
                                                                               *
                                                                               * Get the value of a
                                                                               *tag of arbitrary
                                                                               *type on an entity.
                                                                               *Tag data is passed
                                                                               *back as void*.
                                                                               *tag_value_size
                                                                               *specifies the size
                                                                               *of the memory
                                                                               *pointed to by
                                                                               *tag_value in terms
                                                                               *of bytes.
                                                                               *Applications may use
                                                                               *this function to get
                                                                               *data of any type,
                                                                               *not just
                                                                               *iBase_BYTES.
                                                                               * However, because
                                                                               *this function
                                                                               *supports arbitrary
                                                                               *type, in all cases
                                                                               *the size specified
                                                                               *by tag_value_size is
                                                                               *always in terms of
                                                                               * bytes.
                                                                               ******************************************************************************/

void iMesh_getData( iMesh_Instance instance,
                    /**< [in] iMesh instance handle */
                    const iBase_EntityHandle entity_handle,
                    /**< [in] Entity on which tag is being set */
                    const iBase_TagHandle tag_handle,
                    /**< [in] Tag being set on an entity */
                    void* tag_value,
                    /**< [in,out] Pointer to tag data array being queried
                         \ref trio) */
                    int* tag_value_allocated,
                    /**< [in,out] Pointer to tag data array allocated size */
                    int* tag_value_size,
                    /**< [out] Pointer to occupied size in bytes of tag data */
                    int* err
                    /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnEnts
                                                                               * \brief  Get the
                                                                               *value of a tag of
                                                                               *integer type on an
                                                                               *entity
                                                                               *
                                                                               * Get the value of a
                                                                               *tag of integer type
                                                                               *on an entity.
                                                                               ******************************************************************************/

void iMesh_getIntData( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       const iBase_EntityHandle entity_handle,
                       /**< [in] Entity on which tag is being set */
                       const iBase_TagHandle tag_handle,
                       /**< [in] Tag being set on an entity */
                       int* out_data,
                       /**< [out] Pointer to tag value returned from function */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnEnts
                                                                               * \brief  Get the
                                                                               *value of a tag of
                                                                               *double type on an
                                                                               *entity
                                                                               *
                                                                               * Get the value of a
                                                                               *tag of double type
                                                                               *on an entity.
                                                                               ******************************************************************************/

void iMesh_getDblData( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       const iBase_EntityHandle entity_handle,
                       /**< [in] Entity on which tag is being set */
                       const iBase_TagHandle tag_handle,
                       /**< [in] Tag being set on an entity */
                       double* out_data,
                       /**< [out] Pointer to tag value returned from function */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnEnts
                                                                               * \brief  Get the
                                                                               *value of a tag of
                                                                               *entity handle type
                                                                               *on an entity
                                                                               *
                                                                               * Get the value of a
                                                                               *tag of entity handle
                                                                               *type on an entity.
                                                                               ******************************************************************************/

void iMesh_getEHData( iMesh_Instance instance,
                      /**< [in] iMesh instance handle */
                      const iBase_EntityHandle entity_handle,
                      /**< [in] Entity on which tag is being set */
                      const iBase_TagHandle tag_handle,
                      /**< [in] Tag being set on an entity */
                      iBase_EntityHandle* out_data,
                      /**< [out] Pointer to tag value returned from function */
                      int* err
                      /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnEnts
                                                                               * \brief  Get the
                                                                               *value of a tag of
                                                                               *entity set handle
                                                                               *type on an
                                                                               *
                                                                               *         entity
                                                                               * Get the value of a
                                                                               *tag of entity set
                                                                               *handle type on an
                                                                               *entity.
                                                                               ******************************************************************************/

void iMesh_getESHData( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       const iBase_EntityHandle entity_handle,
                       /**< [in] Entity on which tag is being set */
                       const iBase_TagHandle tag_handle,
                       /**< [in] Tag being set on an entity */
                       iBase_EntitySetHandle* out_data,
                       /**< [out] Pointer to tag value returned from function */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnEnts
                                                                               * \brief  Set a tag
                                                                               *value of arbitrary
                                                                               *type on an entity
                                                                               *
                                                                               * Set a tag value of
                                                                               *arbitrary type on an
                                                                               *entity.  Tag data is
                                                                               *passed as void*.
                                                                               *tag_value_size
                                                                               *specifies the size
                                                                               *of the memory
                                                                               *pointed to by
                                                                               *tag_value in terms
                                                                               *of bytes.
                                                                               *Applications may use
                                                                               *this function to set
                                                                               *data of any type,
                                                                               *not just
                                                                               *iBase_BYTES.
                                                                               * However, because
                                                                               *this function
                                                                               *supports data of
                                                                               *arbitrary type, in
                                                                               * all cases the size
                                                                               *specified by
                                                                               *tag_value_size is
                                                                               *always in terms of
                                                                               *bytes.
                                                                               ******************************************************************************/

void iMesh_setData( iMesh_Instance instance,
                    /**< [in] iMesh instance handle */
                    iBase_EntityHandle entity_handle,
                    /**< [in] Entity on which tag is being set */
                    const iBase_TagHandle tag_handle,
                    /**< [in] Tag being set on an entity */
                    const void* tag_value,
                    /**< [in] Pointer to tag data being set on entity */
                    const int tag_value_size,
                    /**< [in] Size in bytes of tag data */
                    int* err
                    /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnEnts
                                                                               * \brief  Set a tag
                                                                               *value of integer
                                                                               *type on an entity
                                                                               *
                                                                               * Set a tag value of
                                                                               *integer type on an
                                                                               *entity.
                                                                               ******************************************************************************/

void iMesh_setIntData( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       iBase_EntityHandle entity_handle,
                       /**< [in] Entity on which tag is being set */
                       const iBase_TagHandle tag_handle,
                       /**< [in] Tag being set on an entity */
                       const int tag_value,
                       /**< [in] Tag value being set on entity */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnEnts
                                                                               * \brief  Set a tag
                                                                               *value of double type
                                                                               *on an entity
                                                                               *
                                                                               * Set a tag value of
                                                                               *double type on an
                                                                               *entity.
                                                                               ******************************************************************************/

void iMesh_setDblData( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       iBase_EntityHandle entity_handle,
                       /**< [in] Entity on which tag is being set */
                       const iBase_TagHandle tag_handle,
                       /**< [in] Tag being set on an entity */
                       const double tag_value,
                       /**< [in] Tag value being set on entity */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnEnts
                                                                               * \brief  Set a tag
                                                                               *value of entity
                                                                               *handle type on an
                                                                               *entity
                                                                               *
                                                                               * Set a tag value of
                                                                               *entity handle type
                                                                               *on an entity.
                                                                               ******************************************************************************/

void iMesh_setEHData( iMesh_Instance instance,
                      /**< [in] iMesh instance handle */
                      iBase_EntityHandle entity_handle,
                      /**< [in] Entity on which tag is being set */
                      const iBase_TagHandle tag_handle,
                      /**< [in] Tag being set on an entity */
                      const iBase_EntityHandle tag_value,
                      /**< [in] Tag value being set on entity */
                      int* err
                      /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup TagsOnEnts
                                                                               * \brief  Set a tag
                                                                               *value of entity set
                                                                               *handle type on an
                                                                               *entity
                                                                               *
                                                                               * Set a tag value of
                                                                               *entity set handle
                                                                               *type on an entity.
                                                                               ******************************************************************************/

void iMesh_setESHData( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       iBase_EntityHandle entity_handle,
                       /**< [in] Entity on which tag is being set */
                       const iBase_TagHandle tag_handle,
                       /**< [in] Tag being set on an entity */
                       const iBase_EntitySetHandle tag_value,
                       /**< [in] Tag value being set on entity */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Tags
                                                                               * \brief  Get all the
                                                                               *tags associated with
                                                                               *a specified entity
                                                                               *handle
                                                                               *
                                                                               * Get all the tags
                                                                               *associated with a
                                                                               *specified entity
                                                                               *handle
                                                                               ******************************************************************************/

void iMesh_getAllTags( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       const iBase_EntityHandle entity_handle,
                       /**< [in] Entity being queried */
                       iBase_TagHandle** tag_handles,
                       /**< [in,out] Pointer to array of tag_handles returned from
                            \ref trio) */
                       int* tag_handles_allocated,
                       /**< [in,out] Pointer to allocated size of tag_handles  */
                       int* tag_handles_size,
                       /**< [out] Pointer to occupied size of tag_handles array */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Tags
                                                                               * \brief  Remove a
                                                                               *tag value from an
                                                                               *entity
                                                                               *
                                                                               * Remove a tag value
                                                                               *from an entity
                                                                               ******************************************************************************/

void iMesh_rmvTag( iMesh_Instance instance,
                   /**< [in] iMesh instance handle */
                   iBase_EntityHandle entity_handle,
                   /**< [in] Entity from which tag is being removed */
                   const iBase_TagHandle tag_handle,
                   /**< [in] Tag handle of tag being removed */
                   int* err
                   /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *EntityIterators
                                                                               * \brief  Initialize
                                                                               *an iterator over
                                                                               *specified entity
                                                                               *type, topology, and
                                                                               *size
                                                                               *
                                                                               * Initialize an
                                                                               *iterator over
                                                                               *specified entity
                                                                               *type, topology, and
                                                                               *size, for a
                                                                               *specified set or
                                                                               *instance.  Iterator
                                                                               *returned can be used
                                                                               *as input to
                                                                               *functions returning
                                                                               *the entity for the
                                                                               *iterator.  If all
                                                                               *entities of a
                                                                               *specified type
                                                                               *and/or topology are
                                                                               *to be iterated,
                                                                               *specify
                                                                               * iBase_ALL_TYPES or
                                                                               *iMesh_ALL_TOPOLOGIES,
                                                                               *respectively.
                                                                               *Specified type or
                                                                               *topology must be a
                                                                               *value in the
                                                                               *iBase_EntityType or
                                                                               * iMesh_EntityTopology
                                                                               *enumerations,
                                                                               *respectively.
                                                                               *
                                                                               * Note: This function
                                                                               *will fail and return
                                                                               *an error if the
                                                                               *caller passes a
                                                                               * combination of
                                                                               *entity_type and
                                                                               *entity_topology that
                                                                               *are not consistent.
                                                                               ******************************************************************************/

void iMesh_initEntIter( iMesh_Instance instance,
                        /**< [in] iMesh instance handle */
                        const iBase_EntitySetHandle entity_set_handle,
                        /**< [in] Entity set being iterated */
                        const int requested_entity_type,
                        /**< [in] Type of entity to iterate */
                        const int requested_entity_topology,
                        /**< [in] Topology of entity to iterate */
                        const int resilient,
                        /**< [in] If zero, return a non-resilient iterator.
                                  Otherwise, a resilient iterator (\ref resilient) */
                        iBase_EntityIterator* entity_iterator,
                        /**< [out] Pointer to iterator returned from function */
                        int* err
                        /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *EntityIterators
                                                                               * \brief  Get entity
                                                                               *corresponding to an
                                                                               *iterator and
                                                                               *increment iterator
                                                                               *
                                                                               * Get the entity
                                                                               *corresponding to an
                                                                               *iterator (that is,
                                                                               *dereference the
                                                                               *iterator), and
                                                                               *increment the
                                                                               *iterator. The
                                                                               *dereferenced value
                                                                               * is returned in
                                                                               *'entity_handle'. If
                                                                               *the iterator is at
                                                                               *the end of the
                                                                               * iteration, the
                                                                               *dereferenced value
                                                                               *will be undefined
                                                                               *and 'has_data' will
                                                                               *have a value of
                                                                               *zero. Otherwise,
                                                                               *'has_data' will have
                                                                               *a non-zero value.
                                                                               ******************************************************************************/

void iMesh_getNextEntIter( iMesh_Instance instance,
                           /**< [in] iMesh instance handle */
                           iBase_EntityIterator entity_iterator,
                           /**< [in] Iterator being queried */
                           iBase_EntityHandle* entity_handle,
                           /**< [out] Pointer to an entity handle corresponding to the current
                              value of iterator just prior to the call. */
                           int* has_data,
                           /**< [out] Pointer to a flag indicating if the value returned in
                              entity_handle is valid. A non-zero value indicates the value is
                              valid. A zero value indicates the value is NOT valid. */
                           int* err
                           /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *EntityIterators
                                                                               * \brief  Reset the
                                                                               *iterator
                                                                               *
                                                                               * Reset the iterator
                                                                               ******************************************************************************/

void iMesh_resetEntIter( iMesh_Instance instance,
                         /**< [in] iMesh instance handle */
                         iBase_EntityIterator entity_iterator,
                         /**< [in] Iterator to reset */
                         int* err
                         /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *EntityIterators
                                                                               * \brief  Destroy the
                                                                               *specified iterator
                                                                               *
                                                                               * Destroy the
                                                                               *specified iterator
                                                                               ******************************************************************************/

void iMesh_endEntIter( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       iBase_EntityIterator entity_iterator,
                       /**< [in] Iterator which gets destroyed */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Entities
                                                                               * \brief  Get the
                                                                               *entity topology for
                                                                               *the specified entity
                                                                               *
                                                                               * Get the entity
                                                                               *topology for the
                                                                               *specified entity.
                                                                               *Topology returned is
                                                                               *a value in the
                                                                               *iMesh_EntityTopology
                                                                               *enumeration.
                                                                               ******************************************************************************/

void iMesh_getEntTopo( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       const iBase_EntityHandle entity_handle,
                       /**< [in] Entity handle being queried */
                       int* out_topo,
                       /**< [out] Pointer to entity topology returned from function */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup  Entities
                                                                               * \brief  Get the
                                                                               *entity type for the
                                                                               *specified entity
                                                                               *
                                                                               * Get the entity type
                                                                               *for the specified
                                                                               *entity.  Type
                                                                               *returned is a value
                                                                               * in the
                                                                               *iBase_EntityType
                                                                               *enumeration.
                                                                               ******************************************************************************/

void iMesh_getEntType( iMesh_Instance instance,
                       /**< [in] iMesh instance handle */
                       const iBase_EntityHandle entity_handle,
                       /**< [in] Entity handle being queried */
                       int* out_type,
                       /**< [out] Pointer to entity type returned from function */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *VertexEntities
                                                                               * \brief  Get
                                                                               *coordinates of
                                                                               *specified vertex
                                                                               *
                                                                               * Get coordinates of
                                                                               *specified vertex.
                                                                               ******************************************************************************/

void iMesh_getVtxCoord( iMesh_Instance instance,
                        /**< [in] iMesh instance handle */
                        const iBase_EntityHandle vertex_handle,
                        /**< [in] Mesh vertex being queried */
                        double* x,
                        /**< [out] Pointer to x coordinate returned from function */
                        double* y,
                        /**< [out] Pointer to y coordinate returned from function */
                        double* z,
                        /**< [out] Pointer to z coordinate returned from function */
                        int* err
                        /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Adjacencies \brief
                                                                               *Get entities of
                                                                               *specified type
                                                                               *adjacent to an
                                                                               *entity
                                                                               *
                                                                               * Get entities of
                                                                               *specified type
                                                                               *adjacent to an
                                                                               *entity.  Specified
                                                                               *type must be value
                                                                               *in the
                                                                               *iBase_EntityType
                                                                               *enumeration.
                                                                               *
                                                                               * Note 1: Because
                                                                               *'adjacent' as
                                                                               *defined by the iMesh
                                                                               *data model refers to
                                                                               *those entities that
                                                                               *bound another, the
                                                                               *entity being queried
                                                                               *         here (in
                                                                               *entity_handle arg)
                                                                               *is NEVER ALSO
                                                                               *returned in
                                                                               *         adj_entity_handles
                                                                               *even if the
                                                                               *entity_type_requested
                                                                               *         matches the
                                                                               *entity type in
                                                                               *entity_handle.
                                                                               ******************************************************************************/

void iMesh_getEntAdj( iMesh_Instance instance,
                      /**< [in] iMesh instance handle */
                      const iBase_EntityHandle entity_handle,
                      /**< [in] Entity handle being queried */
                      const int entity_type_requested,
                      /**< [in] Type of adjacent entities requested */
                      iBase_EntityHandle** adj_entity_handles,
                      /**< [in,out] Pointer to array of adjacent entities \ref trio) */
                      int* adj_entity_handles_allocated,
                      /**< [in,out] Pointer to allocated size of adj_entity_handles */
                      int* adj_entity_handles_size,
                      /**< [out] Pointer to occupied size of adj_entity_handles */
                      int* err
                      /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *Adjacencies \brief
                                                                               *Get "2nd order"
                                                                               *adjacencies to an
                                                                               *entity
                                                                               *
                                                                               * Get "2nd order"
                                                                               *adjacencies to an
                                                                               *entity, that is,
                                                                               *from an entity,
                                                                               *through other
                                                                               *entities of a
                                                                               *specified "bridge"
                                                                               *dimension, to other
                                                                               *entities of another
                                                                               *specified "to"
                                                                               *dimension. Note 1:
                                                                               *If the "bridge"
                                                                               *dimension is the
                                                                               *same as the "to"
                                                                               *dimension or the
                                                                               *dimension of the
                                                                               *input entity, the
                                                                               *output will be empty
                                                                               *    (and an error
                                                                               *code of
                                                                               *iBase_INVALID_ARGUMENT
                                                                               *returned).  This is
                                                                               *    consistent with
                                                                               *the definition of
                                                                               *adjacencies and the
                                                                               *behavior of iMesh
                                                                               *first adjacency
                                                                               *calls. Note 2: An
                                                                               *entity will never be
                                                                               *returned as a second
                                                                               *adjacency of itself,
                                                                               *on the grounds that
                                                                               *this is the most
                                                                               *likely expectation
                                                                               *of applications, and
                                                                               *that it is easier
                                                                               *for an application
                                                                               *to add the original
                                                                               *entity to the
                                                                               *returned data than
                                                                               *to find and remove
                                                                               *it.
                                                                               ******************************************************************************/

void iMesh_getEnt2ndAdj( iMesh_Instance instance,
                         /**< [in] iMesh instance handle */
                         iBase_EntityHandle entity_handle,
                         /**< [in] Entity from which adjacencies are requested */
                         int bridge_entity_type,
                         /**< [in]  Type of bridge entity for 2nd order adjacencies */
                         int requested_entity_type,
                         /**< [in] Type of adjacent entities returned */
                         iBase_EntityHandle** adjacent_entities,
                         /**< [in,out] Adjacent entities \ref trio) */
                         int* adjacent_entities_allocated,
                         /**< [in,out] Allocated size of returned array */
                         int* adjacent_entities_size,
                         /**< [out] Occupied size of returned array */
                         int* err
                         /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *EntitySetOperators
                                                                               * \brief  Subtract
                                                                               *contents of one
                                                                               *entity set from
                                                                               *another
                                                                               *
                                                                               * Subtract contents
                                                                               *of one entity set
                                                                               *from another
                                                                               ******************************************************************************/

void iMesh_subtract( iMesh_Instance instance,
                     /**< [in] iMesh instance handle */
                     const iBase_EntitySetHandle entity_set_1,
                     /**< [in] Entity set from which other set is being subtracted */
                     const iBase_EntitySetHandle entity_set_2,
                     /**< [in] Entity set being subtracted from other set */
                     iBase_EntitySetHandle* result_entity_set,
                     /**< [out] Pointer to entity set returned from function */
                     int* err
                     /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *EntitySetOperators
                                                                               * \brief  Intersect
                                                                               *contents of one
                                                                               *entity set with
                                                                               *another
                                                                               *
                                                                               * Intersect contents
                                                                               *of one entity set
                                                                               *with another
                                                                               ******************************************************************************/

void iMesh_intersect( iMesh_Instance instance,
                      /**< [in] iMesh instance handle */
                      const iBase_EntitySetHandle entity_set_1,
                      /**< [in] Entity set being intersected with another */
                      const iBase_EntitySetHandle entity_set_2,
                      /**< [in] Entity set being intersected with another */
                      iBase_EntitySetHandle* result_entity_set,
                      /**< [out] Pointer to entity set returned from function */
                      int* err
                      /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \ingroup
                                                                               *EntitySetOperators
                                                                               * \brief  Unite
                                                                               *contents of one
                                                                               *entity set with
                                                                               *another
                                                                               *
                                                                               ******************************************************************************/

void iMesh_unite( iMesh_Instance instance,
                  /**< [in] iMesh instance handle */
                  const iBase_EntitySetHandle entity_set_1,
                  /**< [in] Entity set being united with another */
                  const iBase_EntitySetHandle entity_set_2,
                  /**< [in] Entity set being united with another */
                  iBase_EntitySetHandle* result_entity_set,
                  /**< [out] Pointer to entity set returned from function */
                  int* err
                  /**< [out] Returned Error status (see iBase_ErrorType) */
);

/***************************************************************************/ /**
                                                                               * \page imesh iMesh:
                                                                               *ITAPS Serial Mesh
                                                                               *Interface
                                                                               *
                                                                               * The ITAPS Mesh
                                                                               *Interface iMesh
                                                                               *provides a common
                                                                               *interface for
                                                                               * accessing mesh and
                                                                               *data associated with
                                                                               *a mesh. Applications
                                                                               *written to use this
                                                                               *interface can use a
                                                                               *variety of
                                                                               *implementations,
                                                                               *choosing the one
                                                                               *that best meets its
                                                                               *needs.  They can
                                                                               *also use tools
                                                                               *written to this
                                                                               *interface, for
                                                                               *example mesh
                                                                               *smoothing, adaptive
                                                                               *mesh refinement, and
                                                                               *parallel mesh
                                                                               *support.
                                                                               *
                                                                               * The ITAPS
                                                                               *interfaces use a
                                                                               *data model composed
                                                                               *of four basic data
                                                                               *types: /Entity/:
                                                                               *basic topological
                                                                               *entities in a mesh,
                                                                               *e.g. vertices,
                                                                               * triangles,
                                                                               *hexahedra. /Entity
                                                                               *Set/: arbitrary
                                                                               *grouping of other
                                                                               *entities and sets.
                                                                               * Entity sets also
                                                                               *support parent/child
                                                                               *relations with other
                                                                               *sets which are
                                                                               *distinct from
                                                                               *entities contained
                                                                               *in those sets.
                                                                               *Parent/child links
                                                                               * can be used to
                                                                               *embed graph
                                                                               *relationships
                                                                               *between sets, e.g.
                                                                               *to represent
                                                                               *topological
                                                                               *relationships
                                                                               *between the sets.
                                                                               * /Interface/: the
                                                                               *object with which
                                                                               *mesh is associated
                                                                               *and on which
                                                                               * functions in iMesh
                                                                               *are called. /Tag/:
                                                                               *application data
                                                                               *associated with
                                                                               *objects of any of
                                                                               *the other data
                                                                               *types.  Each tag has
                                                                               *a designated name,
                                                                               *size, and data type.
                                                                               *
                                                                               * ITAPS Entity Type,
                                                                               *Topology Each entity
                                                                               *has a specific
                                                                               *Entity Type and
                                                                               *Entity Topology. The
                                                                               *Entity Type is one
                                                                               *of VERTEX, EDGE,
                                                                               *FACE, and REGION,
                                                                               *and is synonymous
                                                                               *with the topological
                                                                               *dimension of the
                                                                               *entity.  The Entity
                                                                               *Topology denotes the
                                                                               *specific shape, for
                                                                               *example TRIANGLE,
                                                                               *QUADRILATERAL,
                                                                               *TETRAHEDRON, and
                                                                               *HEXAHEDRON.  Entity
                                                                               *Type and Entity
                                                                               *Topology exist as
                                                                               *enumerated types,
                                                                               *Entity Type in the
                                                                               *iBase_EntityType
                                                                               *enumeration, and
                                                                               * Entity Topology in
                                                                               *the
                                                                               *iMesh_EntityTopology
                                                                               *enumeration.
                                                                               *
                                                                               * ITAPS Entity-,
                                                                               *Array-, and
                                                                               *Iterator-Based
                                                                               *Access The iMesh
                                                                               *interface provides
                                                                               *functions for
                                                                               *accessing entities
                                                                               * individually, as
                                                                               *arrays of entities,
                                                                               *or using iterators.
                                                                               *These access methods
                                                                               *have different
                                                                               *memory versus
                                                                               *execution time
                                                                               *tradeoffs, depending
                                                                               *on the
                                                                               *implementation.
                                                                               *
                                                                               * \image html
                                                                               *example_pic.jpeg
                                                                               *
                                                                               * \subpage cycles
                                                                               *
                                                                               * \page cycles Cycles
                                                                               *in Set-Inclusion and
                                                                               *Parent-Child
                                                                               *structures.
                                                                               *
                                                                               * There are two
                                                                               *graph-like
                                                                               *structures in the
                                                                               *iMesh interface and
                                                                               *data model; the
                                                                               *set-inclusion
                                                                               *structure and the
                                                                               *parent-child link
                                                                               *structure. Whether
                                                                               *these structures
                                                                               *support cycles is
                                                                               *relevant to
                                                                               *implementors.
                                                                               *
                                                                               * Over the evolution
                                                                               *of the iMesh data
                                                                               *model and API, both
                                                                               *of these structures
                                                                               *have been viewed
                                                                               *more or less like a
                                                                               *tree and so cycles
                                                                               *seem incompatible
                                                                               *with that notion.
                                                                               *
                                                                               * Allowing a cycle in
                                                                               *the set inclusion
                                                                               *structure implies
                                                                               *all entity sets in
                                                                               *the cycle are all
                                                                               *equal to each other.
                                                                               *That is the only
                                                                               *rational,
                                                                               * model-level view
                                                                               *that would allow
                                                                               *them all to be
                                                                               *(improper) subsets
                                                                               *of each other. On
                                                                               *the other hand if
                                                                               *the iMesh
                                                                               *specification
                                                                               *excludes cycles from
                                                                               *the set inclusion
                                                                               *structure, the time
                                                                               *complexity
                                                                               *(performance) as a
                                                                               * function of the
                                                                               *number of entity
                                                                               *sets may be
                                                                               *prohibitive for
                                                                               * implementations to
                                                                               *detect and prevent
                                                                               *them.
                                                                               *
                                                                               * Allowing a cycle in
                                                                               *the parent-child
                                                                               *link structure seems
                                                                               *likewise hard to
                                                                               *justify. However,
                                                                               *when the
                                                                               *parent-child
                                                                               *structure is viewed
                                                                               *more like a general
                                                                               *graph (a view that
                                                                               *the current API
                                                                               *itself supports even
                                                                               *if the function
                                                                               *names themselves do
                                                                               *not suggest that)
                                                                               *than specifically a
                                                                               *tree, the admission
                                                                               *of cycles there is
                                                                               *potentially more
                                                                               *natural and useful.
                                                                               *
                                                                               * Implementations are
                                                                               *required to support
                                                                               *cycles in the
                                                                               *Parent-Child
                                                                               * structure.
                                                                               *Implementations are
                                                                               *neither required to
                                                                               *support nor required
                                                                               * to explicitly
                                                                               *prevent cycles in
                                                                               *the Set-Inclusion
                                                                               *structure. Portable
                                                                               * applications should
                                                                               *NOT rely on
                                                                               *implementations
                                                                               *support for cycles
                                                                               * in the
                                                                               *set-inclusion
                                                                               *structure.
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup iMesh
                                                                               *iMesh
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup
                                                                               *Initialization
                                                                               *Initialization
                                                                               * \ingroup iMesh
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup Entities
                                                                               *Entities \ingroup
                                                                               *iMesh
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup
                                                                               *VertexEntities
                                                                               *Vertex Entities
                                                                               * \ingroup Entities
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup
                                                                               *EntitySets Entity
                                                                               *Sets \ingroup iMesh
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup
                                                                               *EntitySetOperators
                                                                               *Entity Set Operators
                                                                               * \ingroup EntitySets
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup
                                                                               *Adjacencies
                                                                               *Adjacencies \ingroup
                                                                               *iMesh
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup
                                                                               *EntityIterators
                                                                               *Entity Iterators
                                                                               * \ingroup iMesh
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup Tags Tags
                                                                               * \ingroup iMesh
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup TagData
                                                                               *Tag Data \ingroup
                                                                               *iMesh
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup
                                                                               *TagsOnEnts Tag Data
                                                                               *On Entities \ingroup
                                                                               *TagData
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup
                                                                               *TagsOnSets Tag Data
                                                                               *On Entity Sets
                                                                               * \ingroup TagData
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup TagsOnArr
                                                                               *Tag Data On Arrays
                                                                               *of Entities \ingroup
                                                                               *TagData
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup
                                                                               *MeshModification
                                                                               *Mesh Modification
                                                                               * \ingroup iMesh
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup
                                                                               *ParentChildLinks
                                                                               *Parent Child Links
                                                                               * \ingroup iMesh
                                                                               ******************************************************************************/

/***************************************************************************/ /**
                                                                               * \defgroup Datatypes
                                                                               *Datatypes \ingroup
                                                                               *iMesh
                                                                               ******************************************************************************/

#ifdef __cplusplus
} /* extern "C" */
#endif

#endif /* ifndef _ITAPS_iMesh */
